AVL Trees added

Makefile

@@ -3,7 +3,7 @@ CC=gcc
 CPP=g++
 AR=ar
 RANLIB=ranlib
-CFLAGS= -g -Wall -Wno-unused-function -std=gnu++0x
+CFLAGS= -g -Wall -Wno-unused-function -std=c++11
 SRCDIR = ./src
 INCLUDEDIR = -I./include -I.
 DEPS = 
@@ -70,7 +70,8 @@ PROGRAMS =  m_based_demo \
 			8queue_demo \
 			palindrome_demo \
 			suffix_array_demo \
-			suffix_tree_demo
+			suffix_tree_demo \
+			avl_demo
 
 all: $(PROGRAMS)
 
@@ -79,3 +80,4 @@ all: $(PROGRAMS)
 
 clean:
 	rm -rf $(PROGRAMS) *.dSYM
+

README.md

@@ -35,11 +35,11 @@
     Queue
     Stack
     Binary Heap
-	Fibonacci Heap
+    Fibonacci Heap
     Priority Queue (list based)
 
-	Bubble sort
-	Selection sort
+    Bubble sort
+    Selection sort
     Insertion sort
     Radix sort
     Quick sort
@@ -51,13 +51,14 @@
     Largest common sequence
 
     Binary search tree
+    AVL tree
     Dynamic order statistics
     Red-black tree
     Interval tree
     Prefix Tree(Trie)
     Suffix Tree
     B-Tree
-	Suffix Array
+    Suffix Array
 
     Hash by multiplication
     Hash table
@@ -72,7 +73,7 @@
     Base64
 
     Graph data structure
-	Strongly Connected Components(SCC)
+    Strongly Connected Components(SCC)
     Prim's minimum spanning tree
     Kruskal MST
     Directed/Undirected graph ops
@@ -89,13 +90,14 @@
     K-Means
     Knuth–Morris–Pratt algorithm
     Disjoint-Set
-	8-Queue Problem
-	Palindrome
+    8-Queue Problem
+    Palindrome
 
 ####贡献者 ( Contributors ) :  
-    Samana :  for heavy work of MSVC compatability
+    Samana:  for heavy work of MSVC compatability
     wycg1984: for K-Means
     xmuliang: for HeapSort, Kruskal MST
     wyh267: for base64, LRU, bubble sort, selection sort
     ZhangYou0122: Push-Relabel algorithm, Suffix Tree           
-	UsingtcNower: Suffix Array        
+    UsingtcNower: Suffix Array
+    afernandez90: AVL trees

include/avl.h

@@ -0,0 +1,238 @@
+/*******************************************************************************
+ * ALGORITHM IMPLEMENTAIONS
+ *
+ *  /\  |  _   _  ._ o _|_ |_  ._ _   _ 
+ * /--\ | (_| (_) |  |  |_ | | | | | _> 
+ *         _|                      
+ *
+ * Adelson-Velskii and Landis' (AVL) tree
+ *
+ * Features, being N the number of elements in the tree:
+ * 1. Guaranteed search time is O(log(N)).
+ * 2. Dynamically updated/balanced tree structure O(N) storage.
+ * 3. Exportable to GraphViz format for easy visualization and verification
+ *
+ * http://en.wikipedia.org/wiki/AVL_tree
+ *
+ ******************************************************************************/
+
+#ifndef __AVL_H__
+#define __AVL_H__
+
+#include <iostream>
+#include <cmath>
+#include <stack>
+
+namespace alg {
+
+template <typename T>
+class AVL {
+
+    public:
+
+        AVL() : tree(0), numNodes(0) {}
+
+        T root () const           { return tree->value; }
+        unsigned height() const   { return Node::getHeight(tree); }
+        unsigned size() const     { return numNodes; }
+        bool isEmpty() const      { return numNodes == 0; }
+
+        bool contains(const T &x) const {
+            if (!isEmpty()) {
+                return tree->contains(x);
+            } else return false;
+        }
+
+        void insert(const T &x) {
+            if (isEmpty()) tree = new Node(x);
+            else tree = tree->insert(x);
+            numNodes++;
+        }
+
+        void erase(const T &x) {
+            if (!isEmpty()) {
+                bool found = false;
+                tree = tree->erase(x, found);
+                if (found) numNodes--;
+            }
+        }
+
+        void toGraphViz(std::ostream &stream, std::string name) const {
+            if (!isEmpty()) {
+                stream << "digraph " << name << " {" << std::endl;
+                tree->toGraphViz(stream);
+                stream << "}" << std::endl;
+            }
+        }
+
+    public:
+
+        struct Node {
+            Node *left, *right;
+            T value;
+            unsigned height;
+
+            Node(const T &x) : left(0), right(0), value(x), height(1) {}
+
+            bool contains(const T &x) const {
+                if (value == x) return true;
+                else if (x < value && left != 0) return left->contains(x);
+                else if (right != 0) return right->contains(x);
+                else return false;
+            }
+
+            Node *insert(const T &x) {
+                if (x <= value) {
+                    if (left == 0) left = new Node(x);
+                    else left = left->insert(x);
+                }
+                else {
+                    if (right == 0) right = new Node(x);
+                    else right = right->insert(x);
+                }
+
+                return update();
+            }
+
+            Node *erase(const T &x, bool &found) {
+                if (value == x) {
+                    found = true;
+                    if (left == 0 && right == 0) {
+                        delete this;
+                        return 0;
+                    } else if (left == 0) {
+                        Node *aux = right;
+                        *this = *right;
+                        delete aux;
+                    } else if (right == 0) {
+                        Node *aux = left;
+                        *this = *left;
+                        delete aux;
+                    } else {
+                        // Tracing path to rightmost leaf of the left subtree
+                        std::stack<Node*> trace;
+
+                        Node *current = left;
+                        while (current != 0) {
+                            trace.push(current);
+                            current = current->right;
+                        }
+
+                        current = trace.top();
+                        value = current->value;
+                        Node *lsubtree = current->left;
+                        delete current;
+                        trace.pop();
+
+                        if (trace.empty()) { left = lsubtree; }
+                        else {
+                            trace.top()->right = lsubtree;
+                            trace.pop();
+                            while (!trace.empty()) {
+                                current = trace.top();
+                                current->right = current->right->update();
+                                trace.pop();
+                            }
+                        }
+                    }
+                    return update();
+                }
+                else if (x < value) {
+                    if (left != 0) {
+                        left = left->erase(x, found);
+                        return update();
+                    } else return this;
+                }
+                else {
+                    if (right != 0) {
+                        right = right->erase(x, found);
+                        return update();
+                    } else return this;
+                }
+            }
+
+            Node *update() {
+                updateHeight();
+
+                if (getBF(this) >= 2) {
+                    if (getBF(left) <= -1) LR();
+                    return LL();
+                } else if (getBF(this) <= -2) {
+                    if (getBF(right) >= 1) RL();
+                    return RR();
+                } else return this;
+            }
+
+            void updateHeight() { height = std::max(getHeight(left), getHeight(right)) + 1; }
+
+            void LR() {
+                Node *lrcopy = left->right;
+                left->right = lrcopy->left;
+                lrcopy->left = left;
+                left = lrcopy;
+                left->left->updateHeight();
+                left->updateHeight();
+                updateHeight();
+            }
+
+            void RL() {
+                Node *rlcopy = right->left;
+                right->left = rlcopy->right;
+                rlcopy->right = right;
+                right = rlcopy;
+                right->right->updateHeight();
+                right->updateHeight();
+                updateHeight();
+            }
+
+            Node *LL() {
+                Node *lcopy = left;
+                left = left->right;
+                lcopy->right = this;
+                lcopy->left->updateHeight();
+                lcopy->right->updateHeight();
+                lcopy->updateHeight();
+                return lcopy;
+            }
+
+            Node *RR() {
+                Node *rcopy = right;
+                right = right->left;
+                rcopy->left = this;
+                rcopy->left->updateHeight();
+                rcopy->right->updateHeight();
+                rcopy->updateHeight();
+                return rcopy;
+            }
+
+            static int getBF(const Node *t) {
+                return getHeight(t->left) - getHeight(t->right);
+            }
+
+            static int getHeight(const Node *t) {
+                return t == 0 ? 0 : t->height;
+            }
+
+            void toGraphViz(std::ostream &stream) const {
+                stream << value << ";" << std::endl;
+                if (left != 0) {
+                    stream << left->value << ";" << std::endl;
+                    stream << value << "->" << left->value << ";" << std::endl;
+                    left->toGraphViz(stream);
+                }
+                if (right != 0) {
+                    stream << right->value << ";" << std::endl;
+                    stream << value << "->" << right->value << ";" << std::endl;
+                    right->toGraphViz(stream);
+                }
+            }
+        };
+
+        Node *tree;
+        unsigned numNodes;
+};
+
+}       // namespace alg
+
+#endif  // _ALG_AVL_HPP
+

include/binary_search_tree.h

@@ -8,7 +8,7 @@
  * BINARY SEARCH TREE
  *
  * Features:
- * 1. Expected search time is O(nlogn).
+ * 1. Expected search time is O(log(n)), with worst case O(n).
  * 2. Data should be !!!SHUFFLED!!! first before tree creation.
  * 3. First initialize the value of the root (pointer to the 
  *    structure treeNode) with NULL. eg:

src/avl_demo.cpp

@@ -0,0 +1,66 @@
+#include <iostream>
+#include "avl.h"
+
+using namespace std;
+using namespace alg;
+
+const unsigned N = 4096*32;
+const unsigned N_ELEMS_TO_REMOVE = N-128; // Must be between 0 and N-1
+
+template <typename T> 
+void printTreeStatus(const AVL<T> &t) {
+    cout << "----------------------------------------" << endl;
+    if (t.isEmpty()) cout << "The tree is empty" << endl;
+    else {
+        cout << "Tree root is: " << t.root() << endl;
+        cout << "Tree height is: " << t.height() << endl;
+        cout << "Tree contains " << t.size() << " elements" << endl;
+    }
+    cout << "----------------------------------------" << endl;
+}
+
+int main()
+{
+    int values[N];
+
+    AVL<int> avl;
+
+    cout << "Populating the tree with " << N << " random values... ";
+    for (unsigned i = 0; i < N; ++i) {
+        values[i] = rand();
+        avl.insert(values[i]);
+    }
+    cout << "Done" << endl;
+
+    printTreeStatus(avl);
+
+    for (unsigned i = 0; i < N; ++i) {
+        unsigned idx = rand() % N;
+        if (!avl.contains(values[idx])) 
+	        cout << "ERROR: Value " << values[idx] << " was inserted and not found!" << endl;
+    }
+
+    cout << "Now removing a random element from the tree... ";
+    unsigned idx = rand() % N;
+    avl.erase(values[idx]);
+    cout << "Done" << endl;
+
+    printTreeStatus(avl);
+
+    cout << "Now removing the root of the tree " << N_ELEMS_TO_REMOVE << " times... ";
+    for (unsigned i = 0; i < N_ELEMS_TO_REMOVE; ++i) {
+        avl.erase(avl.root());
+    }
+    cout << "Done" << endl;
+
+    printTreeStatus(avl);
+
+    // Outputting to cerr so the output can be redirected with ./avl_demo 2> <name>.gvz
+    cout << "Do you want to output the GraphViz representation of the tree to the cerr stream (Y/n)? ";
+    char usrInput;
+    cin >> usrInput;
+    if (usrInput == 'Y' || usrInput == 'y') avl.toGraphViz(cerr, "AVL");
+
+    return 0;
+}
+