style: format code

Data Structure/AVLtree.cpp

@@ -3,20 +3,23 @@
 
 using namespace std;
 
-typedef struct node {
+typedef struct node
+{
 	int data;
 	int height;
-	struct node* left;
-	struct node* right;
-}node;
+	struct node *left;
+	struct node *right;
+} node;
 
-int max(int a, int b) {
+int max(int a, int b)
+{
 	return a > b ? a : b;
 }
 
 // Returns a new Node
 
-node* createNode(int data) {
+node *createNode(int data)
+{
 	node *nn = new node();
 	nn->data = data;
 	nn->height = 0;
@@ -27,21 +30,24 @@ node* createNode(int data) {
 
 // Returns height of tree
 
-int height(node *root) {
-	if(root==NULL)
+int height(node *root)
+{
+	if (root == NULL)
 		return 0;
 	return 1 + max(height(root->left), height(root->right));
 }
 
 // Returns difference between height of left and right subtree
 
-int getBalance(node *root) {
+int getBalance(node *root)
+{
 	return height(root->left) - height(root->right);
 }
 
 // Returns Node after Right Rotation
 
-node* rightRotate(node *root) {
+node *rightRotate(node *root)
+{
 	node *t = root->left;
 	node *u = t->right;
 	t->right = root;
@@ -51,7 +57,8 @@ node* rightRotate(node *root) {
 
 // Returns Node after Left Rotation
 
-node* leftRotate(node *root) {
+node *leftRotate(node *root)
+{
 	node *t = root->right;
 	node *u = t->left;
 	t->left = root;
@@ -61,57 +68,65 @@ node* leftRotate(node *root) {
 
 // Returns node with minimum value in the tree
 
-node* minValue(node* root) {
-	if(root->left==NULL)
+node *minValue(node *root)
+{
+	if (root->left == NULL)
 		return root;
 	return minValue(root->left);
 }
 
 // Balanced Insertion
 
-node* insert(node* root, int item) {
+node *insert(node *root, int item)
+{
 	node *nn = createNode(item);
-	if(root == NULL)
+	if (root == NULL)
 		return nn;
-	if(item<root->data)
+	if (item < root->data)
 		root->left = insert(root->left, item);
 	else
 		root->right = insert(root->right, item);
 	int b = getBalance(root);
-	if(b>1) {
-		if(getBalance(root->left)<0)
-			root->left = leftRotate(root->left);  // Left-Right Case
-		return rightRotate(root);				  // Left-Left Case	
+	if (b > 1)
+	{
+		if (getBalance(root->left) < 0)
+			root->left = leftRotate(root->left); // Left-Right Case
+		return rightRotate(root);				 // Left-Left Case
 	}
-	else if(b<-1) {
-		if(getBalance(root->right)>0)
-			root->right = rightRotate(root->right);  // Right-Left Case
-		return leftRotate(root);				    // Right-Right Case
+	else if (b < -1)
+	{
+		if (getBalance(root->right) > 0)
+			root->right = rightRotate(root->right); // Right-Left Case
+		return leftRotate(root);					// Right-Right Case
 	}
 	return root;
 }
 
 // Balanced Deletion
 
-node* deleteNode(node *root, int key) {
-	if(root == NULL)
+node *deleteNode(node *root, int key)
+{
+	if (root == NULL)
 		return root;
-	if(key < root->data)
+	if (key < root->data)
 		root->left = deleteNode(root->left, key);
-	else if(key >  root->data)
+	else if (key > root->data)
 		root->right = deleteNode(root->right, key);
 
-	else {
+	else
+	{
 		// Node to be deleted is leaf node or have only one Child
-		if(!root->right) {
-			node* temp = root->left;
-			delete(root);
+		if (!root->right)
+		{
+			node *temp = root->left;
+			delete (root);
 			root = NULL;
 			return temp;
 		}
-		else if(!root->left) {
-			node* temp = root->right;
-			delete(root);
+		else if (!root->left)
+		{
+			node *temp = root->right;
+			delete (root);
 			root = NULL;
 			return temp;
 		}
@@ -124,36 +139,38 @@ node* deleteNode(node *root, int key) {
 	return root;
 }
 
-
 // LevelOrder (Breadth First Search)
 
-void levelOrder(node* root) {
-	queue<node*> q;
+void levelOrder(node *root)
+{
+	queue<node *> q;
 	q.push(root);
-	while(!q.empty()) {
+	while (!q.empty())
+	{
 		root = q.front();
-		cout<<root->data<<" ";
+		cout << root->data << " ";
 		q.pop();
-		if(root->left)
+		if (root->left)
 			q.push(root->left);
-		if(root->right)
+		if (root->right)
 			q.push(root->right);
 	}
 }
 
-int main() {
+int main()
+{
 	// Testing AVL Tree
 	node *root = NULL;
 	int i;
-	for(i = 1 ; i <= 7 ; i++)
+	for (i = 1; i <= 7; i++)
 		root = insert(root, i);
-	cout<<"LevelOrder: ";
+	cout << "LevelOrder: ";
 	levelOrder(root);
 	root = deleteNode(root, 1); // Deleting key with value 1
-	cout<<"\nLevelOrder: ";
+	cout << "\nLevelOrder: ";
 	levelOrder(root);
-    root = deleteNode(root, 4); // Deletin key with value 4
-	cout<<"\nLevelOrder: ";
+	root = deleteNode(root, 4); // Deletin key with value 4
+	cout << "\nLevelOrder: ";
 	levelOrder(root);
 	return 0;
 }