Improved files and folders name conventions and moved lost files to Misc folder

Data Structures/Trees/AVLTree.java

@@ -0,0 +1,212 @@
+public class AVLtree {
+ 
+    private Node root;
+ 
+    private class Node {
+        private int key;
+        private int balance;
+        private int height;
+        private Node left, right, parent;
+ 
+        Node(int k, Node p) {
+            key = k;
+            parent = p;
+        }
+    }
+ 
+    public boolean insert(int key) {
+        if (root == null)
+            root = new Node(key, null);
+        else {
+            Node n = root;
+            Node parent;
+            while (true) {
+                if (n.key == key)
+                    return false;
+ 
+                parent = n;
+ 
+                boolean goLeft = n.key > key;
+                n = goLeft ? n.left : n.right;
+ 
+                if (n == null) {
+                    if (goLeft) {
+                        parent.left = new Node(key, parent);
+                    } else {
+                        parent.right = new Node(key, parent);
+                    }
+                    rebalance(parent);
+                    break;
+                }
+            }
+        }
+        return true;
+    }
+ 
+    private void delete(Node node){
+        if(node.left == null && node.right == null){
+            if(node.parent == null) root = null;
+            else{
+                Node parent = node.parent;
+                if(parent.left == node){
+                    parent.left = null;
+                }else parent.right = null;
+                rebalance(parent);
+            }
+            return;
+        }
+        if(node.left!=null){
+            Node child = node.left;
+            while (child.right!=null) child = child.right;
+            node.key = child.key;
+            delete(child);
+        }else{
+            Node child = node.right;
+            while (child.left!=null) child = child.left;
+            node.key = child.key;
+            delete(child);
+        }
+    }
+ 
+    public void delete(int delKey) {
+        if (root == null)
+            return;
+        Node node = root;
+        Node child = root;
+ 
+        while (child != null) {
+            node = child;
+            child = delKey >= node.key ? node.right : node.left;
+            if (delKey == node.key) {
+                delete(node);
+                return;
+            }
+        }
+    }
+ 
+    private void rebalance(Node n) {
+        setBalance(n);
+ 
+        if (n.balance == -2) {
+            if (height(n.left.left) >= height(n.left.right))
+                n = rotateRight(n);
+            else
+                n = rotateLeftThenRight(n);
+ 
+        } else if (n.balance == 2) {
+            if (height(n.right.right) >= height(n.right.left))
+                n = rotateLeft(n);
+            else
+                n = rotateRightThenLeft(n);
+        }
+ 
+        if (n.parent != null) {
+            rebalance(n.parent);
+        } else {
+            root = n;
+        }
+    }
+ 
+    private Node rotateLeft(Node a) {
+ 
+        Node b = a.right;
+        b.parent = a.parent;
+ 
+        a.right = b.left;
+ 
+        if (a.right != null)
+            a.right.parent = a;
+ 
+        b.left = a;
+        a.parent = b;
+ 
+        if (b.parent != null) {
+            if (b.parent.right == a) {
+                b.parent.right = b;
+            } else {
+                b.parent.left = b;
+            }
+        }
+ 
+        setBalance(a, b);
+ 
+        return b;
+    }
+ 
+    private Node rotateRight(Node a) {
+ 
+        Node b = a.left;
+        b.parent = a.parent;
+ 
+        a.left = b.right;
+ 
+        if (a.left != null)
+            a.left.parent = a;
+ 
+        b.right = a;
+        a.parent = b;
+ 
+        if (b.parent != null) {
+            if (b.parent.right == a) {
+                b.parent.right = b;
+            } else {
+                b.parent.left = b;
+            }
+        }
+ 
+        setBalance(a, b);
+ 
+        return b;
+    }
+ 
+    private Node rotateLeftThenRight(Node n) {
+        n.left = rotateLeft(n.left);
+        return rotateRight(n);
+    }
+ 
+    private Node rotateRightThenLeft(Node n) {
+        n.right = rotateRight(n.right);
+        return rotateLeft(n);
+    }
+ 
+    private int height(Node n) {
+        if (n == null)
+            return -1;
+        return n.height;
+    }
+ 
+    private void setBalance(Node... nodes) {
+        for (Node n : nodes)
+            reheight(n);
+            n.balance = height(n.right) - height(n.left);
+    }
+ 
+    public void printBalance() {
+        printBalance(root);
+    }
+ 
+    private void printBalance(Node n) {
+        if (n != null) {
+            printBalance(n.left);
+            System.out.printf("%s ", n.balance);
+            printBalance(n.right);
+        }
+    }
+ 
+    private void reheight(Node node){
+        if(node!=null){
+            node.height=1 + Math.max(height(node.left), height(node.right));
+        }
+    }
+ 
+    public static void main(String[] args) {
+        AVLtree tree = new AVLtree();
+ 
+        System.out.println("Inserting values 1 to 10");
+        for (int i = 1; i < 10; i++)
+            tree.insert(i);
+ 
+        System.out.print("Printing balance: ");
+        tree.printBalance();
+    }
+}

Data Structures/Trees/BinaryTree.java

@@ -0,0 +1,268 @@
+/**
+* This entire class is used to build a Binary Tree data structure.
+* There is the Node Class and the Tree Class, both explained below.
+*
+* @author Unknown
+*
+*/
+
+
+/**
+* This class implements the nodes that will go on the Binary Tree.
+* They consist of the data in them, the node to the left, the node
+* to the right, and the parent from which they came from.
+*
+* @author Unknown
+*
+*/
+class Node{
+	/** Data for the node */
+	public int data;
+	/** The Node to the left of this one */
+	public Node left;
+	/** The Node to the right of this one */
+	public Node right;
+	/** The parent of this node */
+	public Node parent;
+
+	/**
+	* Constructor of Node
+	*
+	* @param value Value to put in the node
+	*/
+	public Node(int value){
+		data = value;
+		left = null;
+		right = null;
+		parent = null;
+	}
+}
+
+
+/**
+* A binary tree is a data structure in which an element
+* has two successors(children). The left child is usually
+* smaller than the parent, and the right child is usually
+* bigger.
+*
+* @author Unknown
+*
+*/
+class Tree{
+	/** The root of the Binary Tree */
+	private Node root;
+
+	/**
+	* Constructor
+	*/
+	public Tree(){
+		root = null;
+	}
+
+	/**
+	* Method to find a Node with a certain value
+	*
+	* @param key Value being looked for
+	* @return The node if it finds it, otherwise returns the parent
+	*/
+	public Node find(int key) {
+		Node current = root;
+		while (current != null) {
+			if(key < current.data) {
+				current = current.left;
+			} else if(key > current.data) {
+				current = current.right;
+			} else {	// If you find the value return it
+				return current;
+			}
+		}
+		return null;
+	}
+
+	/**
+	* Inserts certain value into the Binary Tree
+	*
+	* @param value Value to be inserted
+	*/
+	public void put(int value){
+		Node newNode = new Node(value);
+		if(root == null)
+		root = newNode;
+		else{
+			//This will return the soon to be parent of the value you're inserting
+			Node parent = find(value);
+
+			//This if/else assigns the new node to be either the left or right child of the parent
+			if(value < parent.data){
+				parent.left = newNode;
+				parent.left.parent = parent;
+				return;
+			}
+			else{
+				parent.right = newNode;
+				parent.right.parent = parent;
+				return;
+			}
+		}
+	}
+
+	/**
+	* Deletes a given value from the Binary Tree
+	*
+	* @param value Value to be deleted
+	* @return If the value was deleted
+	*/
+	public boolean remove(int value){
+		//temp is the node to be deleted
+		Node temp = find(value);
+
+		//If the value doesn't exist
+		if(temp.data != value)
+		return false;
+
+		//No children
+		if(temp.right == null && temp.left == null){
+			if(temp == root)
+			root = null;
+
+			//This if/else assigns the new node to be either the left or right child of the parent
+			else if(temp.parent.data < temp.data)
+			temp.parent.right = null;
+			else
+			temp.parent.left = null;
+			return true;
+		}
+
+		//Two children
+		else if(temp.left != null && temp.right != null){
+			Node successor = findSuccessor(temp);
+
+			//The left tree of temp is made the left tree of the successor
+			successor.left = temp.left;
+			successor.left.parent = successor;
+
+			//If the successor has a right child, the child's grandparent is it's new parent
+			if(successor.right != null && successor.parent != temp){
+				successor.right.parent = successor.parent;
+				successor.parent.left = successor.right;
+				successor.right = temp.right;
+				successor.right.parent = successor;
+			}
+			if(temp == root){
+				successor.parent = null;
+				root = successor;
+				return true;
+			}
+
+			//If you're not deleting the root
+			else{
+				successor.parent = temp.parent;
+
+				//This if/else assigns the new node to be either the left or right child of the parent
+				if(temp.parent.data < temp.data)
+				temp.parent.right = successor;
+				else
+				temp.parent.left = successor;
+				return true;
+			}
+		}
+		//One child
+		else{
+			//If it has a right child
+			if(temp.right != null){
+				if(temp == root){
+					root = temp.right; return true;}
+
+					temp.right.parent = temp.parent;
+
+					//Assigns temp to left or right child
+					if(temp.data < temp.parent.data)
+					temp.parent.left = temp.right;
+					else
+					temp.parent.right = temp.right;
+					return true;
+				}
+				//If it has a left child
+				else{
+					if(temp == root){
+						root = temp.left; return true;}
+
+						temp.left.parent = temp.parent;
+
+						//Assigns temp to left or right side
+						if(temp.data < temp.parent.data)
+						temp.parent.left = temp.left;
+						else
+						temp.parent.right = temp.left;
+						return true;
+					}
+				}
+			}
+
+			/**
+			* This method finds the Successor to the Node given.
+			* Move right once and go left down the tree as far as you can
+			*
+			* @param n Node that you want to find the Successor of
+			* @return The Successor of the node
+			*/
+			public Node findSuccessor(Node n){
+				if(n.right == null)
+				return n;
+				Node current = n.right;
+				Node parent = n.right;
+				while(current != null){
+					parent = current;
+					current = current.left;
+				}
+				return parent;
+			}
+
+			/**
+			* Returns the root of the Binary Tree
+			*
+			* @return the root of the Binary Tree
+			*/
+			public Node getRoot(){
+				return root;
+			}
+
+			/**
+			* Prints leftChild - root - rightChild
+			*
+			* @param localRoot The local root of the binary tree
+			*/
+			public void inOrder(Node localRoot){
+				if(localRoot != null){
+					inOrder(localRoot.left);
+					System.out.print(localRoot.data + " ");
+					inOrder(localRoot.right);
+				}
+			}
+
+			/**
+			* Prints root - leftChild - rightChild
+			*
+			* @param localRoot The local root of the binary tree
+			*/
+			public void preOrder(Node localRoot){
+				if(localRoot != null){
+					System.out.print(localRoot.data + " ");
+					preOrder(localRoot.left);
+					preOrder(localRoot.right);
+				}
+			}
+
+			/**
+			* Prints rightChild - leftChild - root
+			*
+			* @param localRoot The local root of the binary tree
+			*/
+			public void postOrder(Node localRoot){
+				if(localRoot != null){
+					postOrder(localRoot.left);
+					postOrder(localRoot.right);
+					System.out.print(localRoot.data + " ");
+				}
+			}
+		}

Data Structures/Trees/GenericTree.Java

@@ -0,0 +1,226 @@
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.Scanner;
+
+public class treeclass {
+	private class Node {
+		int data;
+		ArrayList<Node> child = new ArrayList<>();
+	}
+
+	private Node root;
+	private int size;
+
+	/*
+	A generic tree is a tree which can have as many children as it can be
+	It might be possible that every node present is directly connected to
+	root node.
+
+	In this code
+	Every function has two copies: one function is helper function which can be called from
+	main and from that function a private function is called which will do the actual work.
+	I have done this, while calling from main one have to give minimum parameters.
+
+	*/
+	public treeclass() {     //Constructor
+		Scanner scn = new Scanner(System.in);
+		root = create_treeG(null, 0, scn);
+	}
+
+	private Node create_treeG(Node node, int childindx, Scanner scn) {
+		// display
+		if (node == null) {
+			System.out.println("Enter root's data");
+		} else {
+			System.out.println("Enter data of parent of index " + node.data + " " + childindx);
+		}
+		// input
+		node = new Node();
+		node.data = scn.nextInt();
+		System.out.println("number of children");
+		int number = scn.nextInt();
+		for (int i = 0; i < number; i++) {
+			Node childd = create_treeG(node, i, scn);
+			size++;
+			node.child.add(childd);
+		}
+		return node;
+	}
+
+	/*
+	Function to display the generic tree
+	*/
+	public void display() {  //Helper function
+		display_1(root);
+		return;
+	}
+
+	private void display_1(Node parent) {
+		System.out.print(parent.data + "=>");
+		for (int i = 0; i < parent.child.size(); i++) {
+			System.out.print(parent.child.get(i).data + " ");
+		}
+		System.out.println(".");
+		for (int i = 0; i < parent.child.size(); i++) {
+			display_1(parent.child.get(i));
+		}
+		return;
+	}
+
+	/*
+	 One call store the size directly but if you are asked compute size this function to calcuate
+	 size goes as follows
+	 */
+
+	public int size2call() {
+		return size2(root);
+	}
+
+	public int size2(Node roott) {
+		int sz = 0;
+		for (int i = 0; i < roott.child.size(); i++) {
+			sz += size2(roott.child.get(i));
+		}
+		return sz + 1;
+	}
+
+	/*
+	Function to compute maximum value in the generic tree
+	*/
+	public int maxcall() {
+		int maxi = root.data;
+		return max(root, maxi);
+	}
+
+	private int max(Node roott, int maxi) {
+		if (maxi < roott.data)
+			maxi = roott.data;
+		for (int i = 0; i < roott.child.size(); i++) {
+			maxi = max(roott.child.get(i), maxi);
+		}
+
+		return maxi;
+	}
+
+	/*
+	Function to compute HEIGHT of the generic tree
+	*/
+
+	public int heightcall() {
+		return height(root) - 1;
+	}
+
+	private int height(Node node) {
+		int h = 0;
+		for (int i = 0; i < node.child.size(); i++) {
+			int k = height(node.child.get(i));
+			if (k > h)
+				h = k;
+		}
+		return h + 1;
+	}
+
+	/*
+	Function to find whether a number is present in the generic tree or not
+	*/
+
+	public boolean findcall(int info) {
+		return find(root, info);
+	}
+
+	private boolean find(Node node, int info) {
+		if (node.data == info)
+			return true;
+		for (int i = 0; i < node.child.size(); i++) {
+			if (find(node.child.get(i), info))
+				return true;
+		}
+		return false;
+	}
+
+	/*
+	Function to calculate depth of generic tree
+	*/
+	public void depthcaller(int dep) {
+		depth(root, dep);
+	}
+
+	public void depth(Node node, int dep) {
+		if (dep == 0) {
+			System.out.println(node.data);
+			return;
+		}
+		for (int i = 0; i < node.child.size(); i++)
+			depth(node.child.get(i), dep - 1);
+		return;
+	}
+
+	/*
+	Function to print generic tree in pre-order
+	*/
+	public void preordercall() {
+		preorder(root);
+		System.out.println(".");
+	}
+
+	private void preorder(Node node) {
+		System.out.print(node.data + " ");
+		for (int i = 0; i < node.child.size(); i++)
+			preorder(node.child.get(i));
+	}
+
+	/*
+	Function to print generic tree in post-order
+	*/
+	public void postordercall() {
+		postorder(root);
+		System.out.println(".");
+	}
+
+	private void postorder(Node node) {
+		for (int i = 0; i < node.child.size(); i++)
+			postorder(node.child.get(i));
+		System.out.print(node.data + " ");
+	}
+
+	/*
+	Function to print generic tree in level-order
+	*/
+
+	public void levelorder() {
+		LinkedList<Node> q = new LinkedList<>();
+		q.addLast(root);
+		while (!q.isEmpty()) {
+			int k = q.getFirst().data;
+			System.out.print(k + " ");
+
+			for (int i = 0; i < q.getFirst().child.size(); i++) {
+				q.addLast(q.getFirst().child.get(i));
+			}
+			q.removeFirst();
+		}
+		System.out.println(".");
+	}
+
+	/*
+	 Function to remove all leaves of generic tree
+	 */
+	public void removeleavescall() {
+		removeleaves(root);
+	}
+
+	private void removeleaves(Node node) {
+		ArrayList<Integer> arr = new ArrayList<>();
+		for (int i = 0; i < node.child.size(); i++) {
+			if (node.child.get(i).child.size() == 0) {
+				arr.add(i);
+				// node.child.remove(i);
+				// i--;
+			} else
+				removeleaves(node.child.get(i));
+		}
+		for (int i = arr.size() - 1; i >= 0; i--) {
+			node.child.remove(arr.get(i) + 0);
+		}
+	}
+

Data Structures/Trees/TreeTraversal.java

@@ -0,0 +1,92 @@
+/**
+ *
+ * @author Varun Upadhyay (https://github.com/varunu28)
+ *
+ */
+
+// Driver Program
+public class TreeTraversal {
+    public static void main(String[] args) {
+        Node tree = new Node(5);
+        tree.insert(3);
+        tree.insert(7);
+
+        // Prints 3 5 7
+        tree.printInOrder();
+        System.out.println();
+
+        // Prints 5 3 7
+        tree.printPreOrder();
+        System.out.println();
+
+        // Prints 3 7 5
+        tree.printPostOrder();
+        System.out.println();
+    }
+}
+
+/**
+ * The Node class which initializes a Node of a tree
+ * Consists of all 3 traversal methods: printInOrder, printPostOrder & printPreOrder
+ * printInOrder: LEFT -> ROOT -> RIGHT
+ * printPreOrder: ROOT -> LEFT -> RIGHT
+ * printPostOrder: LEFT -> RIGHT -> ROOT
+ */
+class Node {
+    Node left, right;
+    int data;
+
+    public Node(int data) {
+        this.data = data;
+    }
+
+    public void insert (int value) {
+        if (value < data) {
+            if (left == null) {
+                left = new Node(value);
+            }
+            else {
+                left.insert(value);
+            }
+        }
+        else {
+            if (right == null) {
+                right = new Node(value);
+            }
+            else {
+                right.insert(value);
+            }
+        }
+    }
+
+    public void printInOrder() {
+        if (left != null) {
+            left.printInOrder();
+        }
+        System.out.print(data + " ");
+        if (right != null) {
+            right.printInOrder();
+        }
+    }
+
+    public void printPreOrder() {
+        System.out.print(data + " ");
+        if (left != null) {
+            left.printPreOrder();
+        }
+        if (right != null) {
+            right.printPreOrder();
+        }
+    }
+
+    public void printPostOrder() {
+        if (left != null) {
+            left.printPostOrder();
+        }
+        if (right != null) {
+            right.printPostOrder();
+        }
+        System.out.print(data + " ");
+    }
+}
+