Implement AVL Tree

Author: hamednikzad

README.md

@@ -19,6 +19,7 @@ Data structures and algorithms implementation in pure csharp
  - HashTable Chaining (Separate Chaining)
 - Tree
  - Binary Search Tree
+ - AVL
 
 ### Sorting algorithms that have been implemented so far:
  - Bubble Sort

TODO.md

@@ -88,8 +88,8 @@ Here is Data Structures base on https://en.wikipedia.org/wiki/List_of_data_struc
  - [ ] Tree 
  - [ ] Binary trees
  - [ ] AA tree
- - [ ] AVL tree
- - [ ] Binary search tree
+ - [x] AVL tree
+ - [x] Binary search tree
  - [ ] Binary tree
  - [ ] Cartesian tree
  - [ ] Conc-tree list
@@ -110,7 +110,7 @@ Here is Data Structures base on https://en.wikipedia.org/wiki/List_of_data_struc
  - [ ] WAVL tree
  - [ ] Weight-balanced tree
  - [ ] B-trees
- - [ ] B-tree
+ - [x] B-tree
  - [ ] B+ tree
  - [ ] B*-tree
  - [ ] Dancing tree

src/ConsoleApp/Ds/Trees.cs

@@ -1,4 +1,5 @@
-using DataStructures.AbstractDataTypes.Trees;
+using System.Diagnostics;
+using DataStructures.AbstractDataTypes.Trees;
 
 namespace ConsoleApp.Ds;
 
@@ -32,16 +33,22 @@ private static void BinaryTreeUsage()
 
  private static void AvlTreeUsage()
  {
- var tree = new AvlTree<int>();
-
- tree.Root = tree.Insert(tree.Root, 10); 
- tree.Root = tree.Insert(tree.Root, 11); 
- tree.Root = tree.Insert(tree.Root, 12); 
- tree.Root = tree.Insert(tree.Root, 13); 
- tree.Root = tree.Insert(tree.Root, 14); 
- tree.Root = tree.Insert(tree.Root, 15); 
- Console.WriteLine("AVL Tree: ");
- tree.PrintTree(tree.Root);
+ var avlTree = new AvlTree<int>();
+ avlTree.Add(5);
+ avlTree.Add(3);
+ avlTree.Add(7);
+ avlTree.Add(2);
+ avlTree.Add(4);
+ avlTree.Add(13);
+ avlTree.Add(17);
+ avlTree.TraversePreOrder();
+ avlTree.TraverseInOrder();
+ avlTree.TraversePostOrder();
+ Console.WriteLine($"Is 13 Exists: {avlTree.IsExist(13)}");
+ Console.WriteLine("Deleting 7...");
+ avlTree.Delete(7);
+ avlTree.TraverseInOrder();
+ Console.WriteLine($"Is 7 Exists: {avlTree.IsExist(7)}");
  }
 
  public static void Use()

src/DataStructures/AbstractDataTypes/Trees/AvlTree.cs

@@ -6,101 +6,272 @@ public class Node
  {
  public Node? Left, Right;
  public T Data;
- public int Height;
 
  public Node(T data)
  {
  Data = data;
- Height = 1;
  }
  }
 
  private Node? _root;
 
- private static int GetHeight(Node? node)
+ public void Add(T data)
  {
- return node?.Height ?? 0;
- }
+ var newNode = new Node(data);
+ if (_root is null)
+ {
+ _root = newNode;
+ return;
+ }
 
- private static Node RightRotate(Node y)
- {
- var x = y.Left;
- var t2 = x.Right;
- x.Right = y;
- y.Left = t2;
- y.Height = Math.Max(GetHeight(y.Left), GetHeight(y.Right)) + 1;
- x.Height = Math.Max(GetHeight(x.Left), GetHeight(x.Right)) + 1;
- return x;
+ _root = Insert(_root, newNode);
  }
 
- private static Node LeftRotate(Node x)
+ private static Node Insert(Node? current, Node newNode)
  {
- Node y = x.Right;
- Node T2 = y.Left;
- y.Left = x;
- x.Right = T2;
- x.Height = Math.Max(GetHeight(x.Left), GetHeight(x.Right)) + 1;
- y.Height = Math.Max(GetHeight(y.Left), GetHeight(y.Right)) + 1;
- return y;
+ if (current is null)
+ {
+ current = newNode;
+ return current;
+ }
+
+ var comparer = Comparer<T>.Default;
+ var c = comparer.Compare(newNode.Data, current.Data);
+
+ switch (c)
+ {
+ case < 0:
+ current.Left = Insert(current.Left, newNode);
+ current = GetBalancedTree(current);
+ break;
+ case > 0:
+ current.Right = Insert(current.Right, newNode);
+ current = GetBalancedTree(current);
+ break;
+ default:
+ return current; //Exists!
+ }
+
+ return current;
  }
 
- private static int GetBalance(Node? node)
+ public void Delete(T target)
  {
- if (node == null)
- return 0;
- 
- return GetHeight(node.Left) - GetHeight(node.Right);
+ _root = Delete(_root, target);
  }
 
- public Node Insert(Node node, T key)
+ private static Node? Delete(Node? current, T target)
  {
+ if (current is null)
+ {
+ return null;
+ }
+
  var comparer = Comparer<T>.Default;
- if (node == null)
- return (new Node(key));
+ var c = comparer.Compare(target, current.Data);
 
- var c = comparer.Compare(key, node.Data);
  switch (c)
  {
  case < 0:
- node.Left = Insert(node.Left, key);
+ current.Left = Delete(current.Left, target);
+ if (GetBalanceFactor(current) == -2) //here
+ {
+ current = GetBalanceFactor(current.Right) <= 0 ? RotateRr(current) : RotateRl(current);
+ }
+
  break;
  case > 0:
- node.Right = Insert(node.Right, key);
+ current.Right = Delete(current.Right, target);
+ if (GetBalanceFactor(current) == 2)
+ {
+ current = GetBalanceFactor(current.Left) >= 0 ? RotateLl(current) : RotateLr(current);
+ }
+
+ break;
+ default: //Found!
+ if (current.Right != null)
+ {
+ var parent = current.Right;
+ while (parent.Left != null)
+ {
+ parent = parent.Left;
+ }
+
+ current.Data = parent.Data;
+ current.Right = Delete(current.Right, parent.Data);
+ if (GetBalanceFactor(current) == 2)
+ {
+ current = GetBalanceFactor(current.Left) >= 0 ? RotateLl(current) : RotateLr(current);
+ }
+ }
+ else
+ {
+ return current.Left;
+ }
+
  break;
- default:
- return node; //Exists!
  }
 
- node.Height = 1 + Math.Max(GetHeight(node.Left), GetHeight(node.Right));
- int balance = GetBalance(node);
- if (balance > 1 && comparer.Compare(key, node.Left.Data) < 0)
- return RightRotate(node);
- if (balance < -1 && comparer.Compare(key, node.Right.Data) > 0)
- return LeftRotate(node);
- if (balance > 1 && comparer.Compare(key, node.Left.Data) > 0)
+ return current;
+ }
+
+ public bool IsExist(T key)
+ {
+ if (_root is null)
+ return false;
+ var node = Find(key, _root);
+ if (node is null)
+ return false;
+ 
+ var comparer = Comparer<T>.Default;
+ return comparer.Compare(node.Data, key) == 0;
+ }
+
+ private static Node? Find(T target, Node? current)
+ {
+ if (current is null)
+ return null;
+ 
+ var comparer = Comparer<T>.Default;
+ var c = comparer.Compare(target, current.Data);
+ return c switch
  {
- node.Left = LeftRotate(node.Left);
- return RightRotate(node);
- }
+ < 0 => Find(target, current.Left),
+ > 0 => Find(target, current.Right),
+ _ => current
+ };
+ }
 
- if (balance < -1 && comparer.Compare(key, node.Right.Data) < 0)
+ private static Node GetBalancedTree(Node current)
+ {
+ var bFactor = GetBalanceFactor(current);
+ switch (bFactor)
  {
- node.Right = RightRotate(node.Right);
- return LeftRotate(node);
+ case > 1 when GetBalanceFactor(current.Left) > 0:
+ current = RotateLl(current);
+ break;
+ case > 1:
+ current = RotateLr(current);
+ break;
+ case < -1 when GetBalanceFactor(current.Right) > 0:
+ current = RotateRl(current);
+ break;
+ case < -1:
+ current = RotateRr(current);
+ break;
  }
 
- return node;
+ return current;
+ }
+
+ private static Node RotateRr(Node parent)
+ {
+ var pivot = parent.Right;
+ parent.Right = pivot.Left;
+ pivot.Left = parent;
+ return pivot;
+ }
+
+ private static Node RotateLl(Node parent)
+ {
+ var pivot = parent.Left;
+ parent.Left = pivot.Right;
+ pivot.Right = parent;
+ return pivot;
+ }
+
+ private static Node RotateLr(Node parent)
+ {
+ var pivot = parent.Left;
+ parent.Left = RotateRr(pivot);
+ return RotateLl(parent);
+ }
+
+ private static Node RotateRl(Node parent)
+ {
+ var pivot = parent.Right;
+ parent.Right = RotateLl(pivot);
+ return RotateRr(parent);
+ }
+
+ private static int GetBalanceFactor(Node? node)
+ {
+ if (node == null)
+ return 0;
+
+ return GetHeight(node.Left) - GetHeight(node.Right);
  }
 
- public void PrintTree(Node root)
+ private static int GetHeight(Node? current)
  {
- if (root == null)
+ if (current == null)
+ return 0;
+
+ var left = GetHeight(current.Left);
+ var right = GetHeight(current.Right);
+ return Math.Max(left, right) + 1;
+ }
+
+ private int GetDepth()
+ {
+ return GetDepth(_root);
+ }
+
+ private static int GetDepth(Node? parent)
+ {
+ return parent == null ? 0 : Math.Max(GetDepth(parent.Left), GetDepth(parent.Right)) + 1;
+ }
+
+ public void TraversePreOrder()
+ {
+ Console.WriteLine($"TraversePreOrder(LDR) with Depth {GetDepth()}: ");
+ TraversePreOrder(_root);
+ Console.WriteLine();
+ }
+ 
+ public void TraverseInOrder()
+ {
+ Console.WriteLine($"TraverseInOrder(LDR) with Depth {GetDepth()}: ");
+ TraverseInOrder(_root);
+ Console.WriteLine();
+ }
+ 
+ public void TraversePostOrder()
+ {
+ Console.WriteLine($"TraversePostOrder(LDR) with Depth {GetDepth()}: ");
+ TraversePostOrder(_root);
+ Console.WriteLine();
+ }
+ 
+ private static void TraversePreOrder(Node? parent)
+ {
+ if (parent is null)
  return;
- if (root != null)
+
+ Console.Write(parent.Data + " ");
+ TraversePreOrder(parent.Left);
+ TraversePreOrder(parent.Right);
+ }
+ 
+ private static void TraverseInOrder(Node? parent)
+ {
+ while (true)
  {
- PrintTree(root.Left);
- Console.Write(root.Data + " ");
- PrintTree(root.Left);
+ if (parent == null) return;
+
+ TraverseInOrder(parent.Left);
+ Console.Write(parent.Data + " ");
+ parent = parent.Right;
  }
  }
+
+ private static void TraversePostOrder(Node? parent)
+ {
+ if (parent is null)
+ return;
+
+ TraversePostOrder(parent.Left);
+ TraversePostOrder(parent.Right);
+ Console.Write(parent.Data + " ");
+ }
 }