AVL Tree 平衡二叉树

最新推荐文章于 2023-08-28 18:59:15 发布
原创 最新推荐文章于 2023-08-28 18:59:15 发布 · 置顶 · 1.1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#avl #avltree

博客给出了AVL Tree代码的使用例子，为相关技术应用提供参考。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

使用例子：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <iostream.h>

#include "AVLTree.h"

using namespace std;

class CCity
{
public:
    CCity(const char* city = NULL);
    virtual ~CCity();

    virtual int Compare(const CCity& other) const;

    char szCity[32];
};

CCity::CCity(const char* city)
{
    sprintf(szCity,"%s",city);
}

CCity::~CCity()
{
    memset(szCity,0x00,sizeof(szCity));
}

int CCity::Compare(const CCity& other) const
{
    return strcmp(szCity,other.szCity);
}

int main()
{
    bool demo = true;

    if (demo)
    {
        cout << endl << endl << endl;
        cout << "Demo: AVL-Tree with user class" << endl;
        cout << "----------------------------------" << endl;
        CAVLTree<CCity> tree2;
        tree2.Insert(new CCity("London"));
        tree2.Insert(new CCity("Paris"));
        tree2.Insert(new CCity("Moskau"));
        tree2.Insert(new CCity("Helsinki"));
        tree2.Insert(new CCity("Canberra"));
        tree2.Insert(new CCity("Athen"));
        tree2.Insert(new CCity("Irkutsk"));
        tree2.Insert(new CCity("Paris"));
        tree2.Insert(new CCity("Berlin"));
        tree2.Insert(new CCity("Hamburg"));
        tree2.Insert(new CCity("Mexico"));
        tree2.Insert(new CCity("Aden"));
        tree2.Insert(new CCity("Rom"));
        // create an iterator and iterate throw all nodes in the tree
        //  for sorted output
        CAVLTreeIterator<CCity> iter2(tree2);
        for (iter2.MoveFirst(); iter2; iter2++)
        {
            // note: GetData() returns CCity*
            cout << iter2.GetData()->szCity << endl;
        }
        cout << "----------------------------------" << endl;

        CCity city1("Paris");
        CCity city2("Frankfurt");
        if (tree2.Search(city1))
            cout << "\"" << city1.szCity << "\" is in the tree." << endl;
        else
            cout << "\"" << city1.szCity << "\" is in not the tree." << endl;
        if (tree2.Search(city2))
            cout << "\"" << city2.szCity << "\" is in the tree." << endl;
        else
            cout << "\"" << city2.szCity << "\" is in not the tree." << endl;
        cout << "Press any key to continue" << endl;
        cout << "nodes:" << tree2.GetRoot()->NodesInTree()<<endl;
        cout << "depth:" << tree2.GetDepth()<<endl;
        cout << "NODES:" << tree2.NodesInTree() << endl;
    }

    return 0;
}


AVL Tree  代码：

// Creator: Andreas J?ger
//          Ortsstr. Nr. 2
//        D-07407 Geitersdorf
//
// Last updated: 17. April 1999
// e-mail: Jaeger-Geitersdorf@t-online.de
//
//
// Copyright and author:
// Andreas J?ger: Jaeger-Geitersdorf@t-online.de
//
// You may handle this code to others only when you do not delete these
// copyright-lines.
// These source files may not be copied except by permission of the author.
// These source files may not be included in source or compiled form as any
// part of a commercial distribution except by permission of the
// author.
// These files may be used freely for internal corporate use.
// These files may also may be used freely by students for
// educational purposes.
// No warranty or guarrantee of fitness can be made to these files.
//
//
// have fun!
//
// Updates:
//
// * 15.11.1998 - Some fixes in Delete()- and RestructureDelete()-
//                routines which could make the tree inconsistent
//                and result in a GPF (after lots of Insert- and
//                Delete-operations)
//              - Rename Level() -> GetLevel()
//              - new methods GetDepth() and NodesInTree() for
//                CAVLTree class
//              - new (debug) function CheckBalances()
//              - Draw() function only in Visual C++ environment
//                (not Borland) for portability
//              - updated sample project
//
// * 17.04.1999 - Enhancement of CAVLTreeIterator: delete current node
//
////////////////////////////////////////////////////////////////
// Note:                                                      //
// there must be a function T::Compare(T&)                    //
// or the function Compare of teh Template-Klasse             //
// CAVLNode<T> has to be overridden.                          //
////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////
// Vorbemerkungen:                                            //
// Es mu? eine Funktion T::Compare(T&) definiert sein         //
// oder es mu? die Funktion Compare der Template-Klasse       //
// CAVLNode<T> ?berschrieben werden.                          //
////////////////////////////////////////////////////////////////

// Forward-Deklarationen
//template <class T>
//class CAVLNode;

#ifndef __AVL_TREE_H__
#define __AVL_TREE_H__

template <class T>
class CAVLTree;

template <class T>
class CAVLTreeIterator;

/* siehe unter
template <class T>
class CAVLTreeDialog;
*/

////////////////////////////////////////////////////////////////
// AVL-treenode (=subtree) (Template-Version)                 //
////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////
// AVL-Baumknoten (=Teilbaum) (Template-Variante)             //
////////////////////////////////////////////////////////////////

template <class T>
class CAVLNode
{
public:
    // standard constructor, constructors, destructor
    // Standard-Konstruktor, Konstruktor(en) und Destruktor
    CAVLNode(
			T* data,
			int balance = 0,
			CAVLNode<T>* parent = NULL,
			CAVLNode<T>* left = NULL,
			CAVLNode<T>* right = NULL
	);
    virtual ~CAVLNode();

    // searching
    // Suchen
    CAVLNode<T>* Search(const T* data);

    // comparing
    // Vergleich
    static int Compare(const T& t1, const T& t2);

    // information about the position in the tree
    // Informationen ?ber die Position im Baum
    bool IsRoot() const;
    bool IsLeftSibling() const;
    bool IsRightSibling() const;
    bool HasLeftSibling() const;
    bool HasRightSibling() const;

    // further information
    // Weitere Informationen
    int GetDepth() const;
    int GetLevel() const;
    int NodesInTree() const;

    // navigation in the tree
    // Navigation im Baum
    CAVLNode<T>* GetRoot();

    CAVLNode<T>* GetLeftSibling();
    CAVLNode<T>* GetRightSibling();

    CAVLNode<T>* GetFirstNodeInOrder();
    CAVLNode<T>* GetLastNodeInOrder();

    CAVLNode<T>* GetPrevNodeInOrder();
    CAVLNode<T>* GetNextNodeInOrder();

    // restructuration
    // Restrukturierungs-Ma?nahmen
    bool LeftRotation();
    bool RightRotation();
    bool DoubleRotationLeft();
    bool DoubleRotationRight();


    // Diagnostics
    bool CheckBalances(const char * buffer = NULL, unsigned int buflen = 0) const;

    // drawing into a device context, not fully implemented
    // Visualisierung in einem Ger?tekontext
#ifdef _MSC_VER
    void Draw(CDC* dc, CRect& rect);
#endif

    // item-data
    // Datenelement
    T* Data;

    // informationen about the height of the subtrees
    // -1: left subtree is by 1 higher than the right one
    //  0: both subtrees have the same height
    //  1: right subtree is by 1 higher than the left one

    // Informationen ?ber die Tiefe der Teilb?ume
    // -1: linker Baum ist um 1 tiefer als rechter
    //  0: beide Teilb?ume haben die gleiche Tiefe
    //  1: rechter Baum ist um 1 tiefer als linker

    int Balance;

    // parent node
    // ?bergeordneter Knoten
    CAVLNode<T>* Parent;

    // left and right subtree
    // Linker und rechter Teilbaum
    CAVLNode<T>* Left;
    CAVLNode<T>* Right;
private:
    CAVLNode<T>* GetInsertPosition(const T* data);
    bool RestructureInsert();
    bool RestructureDelete();

    CAVLNode(const CAVLNode<T>& /*tree*/) {};
    CAVLNode& operator= (const CAVLNode<T>& /*tree*/) {return *this;};

    friend class CAVLTree<T>;
};

template <class T>
CAVLNode<T>::CAVLNode(T* data, int balance, CAVLNode<T>* parent, CAVLNode<T>* left, CAVLNode<T>* right)
    : Data(data),
      Balance(balance),
      Parent(parent),
      Left(left),
      Right(right)
{
};

template <class T>
CAVLNode<T>::~CAVLNode()
{
    delete Left;
    delete Right;
    delete Data;
};

template <class T>
bool CAVLNode<T>::RestructureInsert()
{
    CAVLNode<T>* item = this;
    while (!item->IsRoot())
    {
        // rule 1
        // Regel 1
        if (item->IsLeftSibling() && item->Parent->Balance == 0)
        {
            item->Parent->Balance = -1;
            item = item->Parent;
            continue;
        }
        if (item->IsRightSibling() && item->Parent->Balance == 0)
        {
            item->Parent->Balance = 1;
            item = item->Parent;
            continue;
        }
        // rule 2
        // Regel 2
        if (item->IsLeftSibling() && item->Parent->Balance == 1)
        {
            item->Parent->Balance = 0;
            break;
        }
        if (item->IsRightSibling() && item->Parent->Balance == -1)
        {
            item->Parent->Balance = 0;
            break;
        }
        // rule 3
        // Regel 3
        if (item->IsLeftSibling() && item->Parent->Balance == -1)
        {
            if (item->Balance == 1)
                item->Parent->DoubleRotationLeft();
            else
                item->Parent->RightRotation();
            break;
        }
        if (item->IsRightSibling() && item->Parent->Balance == 1)
        {
            if (item->Balance == -1)
                item->Parent->DoubleRotationRight();
            else
                item->Parent->LeftRotation();
            break;
        }
    }
    return true;
};

template <class T>
bool CAVLNode<T>::RestructureDelete()
{
    // Regeln f?r den Elternknoten des gerade gel?schten Blattes
    // anwenden, bevor mit dem eigentlichen Aufstieg begonnen
    // werden kann
    CAVLNode<T>* item = this;
    // Regel 1
    if (item->Balance == 0 && item->Left == NULL)
    {
        item->Balance = 1;
        return true;
    }
    if (item->Balance == 0 && item->Right == NULL)
    {
        item->Balance = -1;
        return true;
    }
    // Regel 2
    if (item->Balance == -1 && item->Left == NULL)
    {
        item->Balance = 0;
    }
    if (item->Balance == 1 && item->Right == NULL)
    {
        item->Balance = 0;
    }
    // Regel 3
    if (item->Balance == -1 && item->Right == NULL)
    {
        if (item->Left->Balance == 1)
        {
            item->DoubleRotationLeft();
            item = item->Parent; // Zeiger sind durch die Rotation etwas verrutscht
        }
        else
        {
            item->RightRotation();
            item = item->Parent; // Zeiger sind durch die Rotation etwas verrutscht
        }
        if (item->Balance == 1)
            return true;
    }
    if (item->Balance == 1 && item->Left == NULL)
    {
        if (item->Right->Balance == -1)
        {
            item->DoubleRotationRight();
            item = item->Parent; // Zeiger sind durch die Rotation etwas verrutscht
        }
        else
        {
            item->LeftRotation();
            item = item->Parent; // Zeiger sind durch die Rotation etwas verrutscht
        }
        if (item->Balance == -1)
            return true;
        //return true;
    }
    // Beginn des eigentlichen Aufstiegs
    while (!item->IsRoot())
    {
        // Regel 1
        if (item->IsLeftSibling() && item->Parent->Balance == 0)
        {
            item->Parent->Balance = 1;
            break;
        }
        if (item->IsRightSibling() && item->Parent->Balance == 0)
        {
            item->Parent->Balance = -1;
            break;
        }
        // Regel 2
        if (item->IsLeftSibling() && item->Parent->Balance == -1)
        {
            item->Parent->Balance = 0;
            item = item->Parent;
            continue;
        }
        if (item->IsRightSibling() && item->Parent->Balance == 1)
        {
            item->Parent->Balance = 0;
            item = item->Parent;
            continue;
        }
        // Regel 3
        if (item->IsRightSibling() && item->Parent->Balance == -1)
        {
            if (item->Parent->Left->Balance == 1)
            {
                item->Parent->DoubleRotationLeft();
                item = item->Parent->Parent; // Zeiger sind durch die Rotation etwas verrutscht
            }
            else
            {
                item->Parent->RightRotation();
                item = item->Parent->Parent; // Zeiger sind durch die Rotation etwas verrutscht
            }
            if (item->Balance == 1)
                return true;
            continue;
        }
        if (item->IsLeftSibling() && item->Parent->Balance == 1)
        {
            if (item->Parent->Right->Balance == -1)
            {
                item->Parent->DoubleRotationRight();
                item = item->Parent->Parent; // Zeiger sind durch die Rotation etwas verrutscht
            }
            else
            {
                item->Parent->LeftRotation();
                item = item->Parent->Parent; // Zeiger sind durch die Rotation etwas verrutscht
            }
            if (item->Balance == -1)
                return true;
            continue;
        }
        // Never appears...
        break;
    }
    return true;
};

template <class T>
CAVLNode<T>* CAVLNode<T>::Search(const T* data)
{
    switch (Compare(*Data, *data))
    {
    case -1:
        if (!Right) return NULL;
        return Right->Search(data);
    case  0: return this;
    case  1:
        if (!Left) return NULL;
        return Left->Search(data);
    }
    return NULL;
};

template <class T>
int CAVLNode<T>::Compare(const T& t1, const T& t2)
{
    return t1.Compare(t2);
};

template <class T>
bool CAVLNode<T>::IsRoot() const
{
    return Parent == NULL;
};

template <class T>
bool CAVLNode<T>::IsLeftSibling() const
{
    return !IsRoot() && Parent->Left == this;
};

template <class T>
bool CAVLNode<T>::IsRightSibling() const
{
    return !IsRoot() && Parent->Right == this;
};

template <class T>
bool CAVLNode<T>::HasLeftSibling() const
{
    return !IsRoot() && IsRightSibling() && Parent->Left != NULL;
};

template <class T>
bool CAVLNode<T>::HasRightSibling() const
{
    return !IsRoot() && IsLeftSibling() && Parent->Right != NULL;
};

template <class T>
int CAVLNode<T>::GetDepth() const
{
    int i = 0;
    if (Left != NULL)
        i = Left->GetDepth();
    if (Right != NULL)
        i = max(i, Right->GetDepth());
    return i+1;
};

template <class T>
int CAVLNode<T>::GetLevel() const
{
    const CAVLNode<T>* item = this;
    int level = 0;
    while (item->Parent != NULL)
    {
        item = item->Parent;
        level++;
    }
    return level;
};

template <class T>
int CAVLNode<T>::NodesInTree() const
{
    int Nodes = 1;
    if (Left != NULL)
        Nodes += Left->NodesInTree();
    if (Right != NULL)
        Nodes += Right->NodesInTree();
    return Nodes;
};

template <class T>
CAVLNode<T>* CAVLNode<T>::GetRoot()
{
    CAVLNode<T>* item = this;
    while (item->Parent != NULL) item = item->Parent;
    return item;
};

template <class T>
CAVLNode<T>* CAVLNode<T>::GetLeftSibling()
{
    if (IsRoot() || IsLeftSibling()) return NULL;
    return Parent->Left;
};

template <class T>
CAVLNode<T>* CAVLNode<T>::GetRightSibling()
{
    if (IsRoot() || IsRightSibling()) return NULL;
    return Parent->Right;
};

template <class T>
CAVLNode<T>* CAVLNode<T>::GetFirstNodeInOrder()
{
    CAVLNode<T>* item = this;
    while (item->Left != NULL)
    {
        item = item->Left;
    }
    return item;
};

template <class T>
CAVLNode<T>* CAVLNode<T>::GetLastNodeInOrder()
{
    CAVLNode<T>* item = this;
    while (item->Right != NULL)
    {
        item = item->Right;
    }
    return item;
};

template <class T>
CAVLNode<T>* CAVLNode<T>::GetPrevNodeInOrder()
{
    if (Left != NULL)
    {
        return Left->GetLastNodeInOrder();
    }
    if (IsRightSibling()) return Parent;
    CAVLNode<T>* item = this;
    while (!item->IsRoot())
    {
        if (item->IsLeftSibling())
            item = item->Parent;
        else
            return item->Parent;
    }
    return NULL;
};

template <class T>
CAVLNode<T>* CAVLNode<T>::GetNextNodeInOrder()
{
    if (Right != NULL)
    {
        return Right->GetFirstNodeInOrder();
    }
    if (IsLeftSibling()) return Parent;
    CAVLNode<T>* item = this;
    while (!item->IsRoot())
    {
        if (item->IsRightSibling())
            item = item->Parent;
        else
            return item->Parent;
    }
    return NULL;
};

template <class T>
CAVLNode<T>* CAVLNode<T>::GetInsertPosition(const T* data)
{
    switch (Compare(*Data, *data))
    {
    case -1:
        if (!Right) return this;
        return Right->GetInsertPosition(data);
    case  0:
        return NULL; // Fehler, Objekt schon im Baum
        // error, object already in the tree (only inserted once!)
    case  1:
        if (!Left) return this;
        return Left->GetInsertPosition(data);
    }
    return NULL; // tritt nie auf
    // never happens
};

template <class T>
bool CAVLNode<T>::LeftRotation()
{
    assert(Right != NULL);

    if (Right == NULL) return false;

    CAVLNode<T>* b = Right;
    // Falls nicht die Wurzel: Knoten b wird Kind
    if (!IsRoot())
    {
        if (IsLeftSibling())
            Parent->Left = b;
        else
            Parent->Right = b;
        b->Parent = Parent;
    }
    else
    {
        b->Parent = NULL;
    }

    // Zeiger korrekt umsetzen
    Right = b->Left;
    b->Left = this;

    // Elternzeiger setzen
    Parent = b;
    if (Right != NULL) Right->Parent = this;

    // Balancen setzen
    if (b->Balance == 0)
    {
        Balance = 1;
        b->Balance = -1;
    }
    else
    {
        Balance = 0;
        b->Balance = 0;
    }

    return true;
};

template <class T>
bool CAVLNode<T>::RightRotation()
{
    assert(Left != NULL);

    if (Left == NULL) return false;

    CAVLNode<T>* b = Left;
    // Falls nicht die Wurzel: Knoten b wird Kind
    if (!IsRoot())
    {
        if (IsLeftSibling())
            Parent->Left = b;
        else
            Parent->Right = b;
        b->Parent = Parent;
    }
    else
    {
        b->Parent = NULL;
    }

    // Zeiger korrekt umsetzen
    Left = b->Right;
    b->Right = this;

    // Elternzeiger setzen
    Parent = b;
    if (Left != NULL) Left->Parent = this;

    // Balancen setzen
    if (b->Balance == 0)
    {
        Balance = -1;
        b->Balance = 1;
    }
    else
    {
        Balance = 0;
        b->Balance = 0;
    }

    return true;
};

template <class T>
bool CAVLNode<T>::DoubleRotationLeft()
{
    assert(Left != NULL && Left->Right != NULL);

    if (Left == NULL || Left->Right == NULL) return false;

    CAVLNode<T>* b = Left;
    CAVLNode<T>* c = Left->Right;

    // Falls nicht die Wurzel: Knoten c wird Kind
    if (!IsRoot())
    {
        if (IsLeftSibling())
            Parent->Left = c;
        else
            Parent->Right = c;
    }

    // Zeiger korrekt umsetzen
    b->Right = c->Left;
    Left = c->Right;
    c->Left = b;
    c->Right = this;

    // Elternzeiger setzen
    c->Parent = Parent;
    Parent = c;
    b->Parent = c;
    if (b->Right != NULL) b->Right->Parent = b;
    if (Left != NULL) Left->Parent = this;

    // Balancen setzen
    switch (c->Balance)
    {
    case -1:
        Balance = 1;
        b->Balance = 0;
        break;
    case 0:
        Balance = 0;
        b->Balance = 0;
        break;
    case 1:
        Balance = 0;
        b->Balance = -1;
        break;
    }
    c->Balance = 0;

    return true;
};

template <class T>
bool CAVLNode<T>::DoubleRotationRight()
{
    assert(Right != NULL && Right->Left != NULL);

    if (Right == NULL || Right->Left == NULL) return false;

    CAVLNode<T>* b = Right;
    CAVLNode<T>* c = Right->Left;

    // Falls nicht die Wurzel: Knoten c wird Kind
    if (!IsRoot())
    {
        if (IsLeftSibling())
            Parent->Left = c;
        else
            Parent->Right = c;
    }

    // Zeiger korrekt umsetzen
    Right = c->Left;
    b->Left = c->Right;
    c->Left = this;
    c->Right = b;

    // Elternzeiger setzen
    c->Parent = Parent;
    Parent = c;
    b->Parent = c;
    if (Right != NULL) Right->Parent = this;
    if (b->Left != NULL) b->Left->Parent = b;

    // Balancen setzen
    switch (c->Balance)
    {
    case -1:
        Balance = 0;
        b->Balance = 1;
        break;
    case 0:
        Balance = 0;
        b->Balance = 0;
        break;
    case 1:
        Balance = -1;
        b->Balance = 0;
        break;
    }
    c->Balance = 0;

    return true;
};

#ifdef _MSC_VER
template <class T>
void CAVLNode<T>::Draw(CDC* dc, CRect& rect)
{
    int depth = GetDepth();
    CSize Size = dc->GetTextExtent(*Data);
    dc->TextOut((rect.left+rect.right)/2-Size.cx/2, rect.top, *Data);

    if (Left != NULL)
    {
        CRect rect1 = rect;
        rect1.top += 2*Size.cy;
        rect1.right = (rect.right+rect.left)/2;
        dc->MoveTo((rect.left+rect.right)/2, rect.top+Size.cy);
        dc->LineTo((rect1.left+rect1.right)/2, rect1.top);
        Left->Draw(dc, rect1);
    }
    if (Right != NULL)
    {
        CRect rect2 = rect;
        rect2.top += 2*Size.cy;
        rect2.left = (rect.right+rect.left)/2;
        dc->MoveTo((rect.left+rect.right)/2, rect.top+Size.cy);
        dc->LineTo((rect2.left+rect2.right)/2, rect2.top);
        Right->Draw(dc, rect2);
    }
};
#endif

////////////////////////////////////////////////////////////////
// AVL-Tree (Template-Version)                                //
////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// AVL-Baum (Template-Variante)                               //
////////////////////////////////////////////////////////////////

// Requirements for the class T:
// Objects of class T must be comparable.
// A function
// int T::Compare(const T& t) const
// must be implemented.
// Return values:
//    -1, if *this <  t
//     0, if *this == t
//     1, if *this >  t

// Anforderungen an die Klasse T:
// Objekte der Klasse T m?ssen vergleichbar sein.
// Der Vergleich erfolgt ?ber eine Funktion
// int T::Compare(const T& t) const
// R?ckgabewerte:
//    -1, falls *this <  t
//     0, falls *this == t
//     1, falls *this >  t

template <class T>
class CAVLTree
{
public:
    // construction and destruction
    // Standard-Konstruktor, Konstruktor und Destruktor
    CAVLTree();
    virtual ~CAVLTree();

    // information
    // Informationen
    bool IsEmpty() const;
    int GetDepth() const;
    long NodesInTree() const;

    // access to the root of the tree
    // Zugriff auf die Wurzel
    CAVLNode<T>* GetRoot();

    // insert and delete
    // Insert und Delete
    CAVLNode<T>* Insert(T* data, bool autodelete = true);
    bool Delete(T* data);

    bool DeleteAll();

    // delete current node of an iterator
    // Aktuellen Knoten eines Iterators l?schen
    bool Delete(CAVLTreeIterator<T>& iter, bool movenext = true);

    // search
    // Suchen
    virtual CAVLNode<T>* Search(const T* data);
    virtual CAVLNode<T>* Search(T& data);

#ifdef _MSC_VER
//    void Draw(CDC* dc, CRect& rect);
#endif

private:
    CAVLNode<T>* Tree;

    friend class CAVLTreeIterator<T>;
    /* siehe unten
    friend class CAVLTreeDialog<T>;
    */
};

template <class T>
CAVLTree<T>::CAVLTree() : Tree(NULL)
{
};

template <class T>
CAVLTree<T>::~CAVLTree()
{
    delete Tree;
};

template <class T>
bool CAVLTree<T>::IsEmpty() const
{
    return Tree == NULL;
};

template <class T>
int CAVLTree<T>::GetDepth() const
{
    if (Tree == NULL) return 0;
    return Tree->GetDepth();
};

template <class T>
CAVLNode<T>* CAVLTree<T>::Insert(T* data, bool autodelete)
{
    // if the tree is empty, the root is used to store the entry

    // Wenn der Baum noch leer ist, kann (und mu?) die Wurzel
    // selbst dazu benutzt werden, um den Eintrag aufzunehmen
    if (IsEmpty())
    {
        Tree = new CAVLNode<T>(data, 0, NULL, NULL, NULL);
        return Tree;
    }
    // detect insert position
    // Einf?geposition ermitteln
    CAVLNode<T>* item = Tree->GetInsertPosition(data);
    if (item == NULL)
    {
        if (autodelete)
            delete data;
        return NULL;
    }
    // create a new node
    // Neuen Knoten erzeugen
    CAVLNode<T>* newitem = new CAVLNode<T>(data, 0, item, NULL, NULL);
    // link with parents
    // Mit Eltern verkn?pfen
    if (CAVLNode<T>::Compare(*(item->Data), *data) == -1)
        item->Right = newitem;
    else
        item->Left = newitem;
    // restructuration
    //Restrukturierungs-Ma?nahmen
    newitem->RestructureInsert();
    Tree = Tree->GetRoot();
    // return the new inserted node
    // R?ckgabe des neu eingef?gten Knotens
    return newitem;
};

template <class T>
bool CAVLTree<T>::Delete(T* data)
{
    // if the tree is empty there is nothing to delete
    // Wenn der Baum leer ist, gibt es auch nichts zu l?schen
    if (IsEmpty()) return false;
    CAVLNode<T>* item = Tree->Search(data);
    if (item == NULL) return false; // Element nicht im Baum
    // element not in the tree

    // if we want to delete the root item, we have to do some extra
    // operation the preserve some pointers...
    // Wenn die Wurzel gel?scht werden soll, m?ssen entsprechende
    // Vorkehrungen getroffen werden, um den Zeiger nicht zu
    // verlieren
    if (item == Tree)
    {
        // the root is the only one node in the tree
        // Die Wurzel ist der einzige Knoten im Baum
        if (item->Left == NULL && item->Right == NULL)
        {
            delete Tree;
            Tree = NULL;
            return true;
        }
    }
    // start node for restructuration
    // Startknoten f?r Restrukturierung
    CAVLNode<T>* startitem = NULL;
    // node to delete has no children
    // Zu l?schender Knoten hat keine S?hne
    if (item->Left == NULL && item->Right == NULL)
    {
        if (item->IsLeftSibling())
            item->Parent->Left = NULL;
        else
            item->Parent->Right = NULL;
        startitem = item->Parent;
        delete item;
        item = NULL;
    }
    // node to delete has only right son
    // Zu l?schender Knoten hat nur rechten Sohn
    if (item != NULL && item->Left == NULL && item->Right != NULL)
    {
        delete item->Data;
        item->Data = item->Right->Data;
        item->Right->Data = NULL;
        delete item->Right;
        item->Right = NULL;
        startitem = item;
    }
    // node to delete has only left son
    // Zu l?schender Knoten hat nur linken Sohn
    if (item != NULL && item->Left != NULL && item->Right == NULL)
    {
        delete item->Data;
        item->Data = item->Left->Data;
        item->Left->Data = NULL;
        delete item->Left;
        item->Left = NULL;
        startitem = item;
    }
    // node to delete has both sons
    // Zu l?schender Knoten hat beide S?hne
    if (item != NULL && item->Left != NULL && item->Right != NULL)
    {
        CAVLNode<T>* y = item->Left->GetLastNodeInOrder();
        CAVLNode<T>* z = y->Left;
        delete item->Data;
        item->Data = y->Data;
        y->Data = NULL;
        /*
        if (y->IsLeftSibling())
            y->Parent->Left = z;
        else
            y->Parent->Right = z;
        */
        if (z != NULL)
        {
            y->Data = z->Data;
            z->Data = NULL;
            y->Left = NULL;
            delete z;
            startitem = y;
        }
        else
        {
            if (y->IsLeftSibling())
                y->Parent->Left = NULL;
            else
                y->Parent->Right = NULL;
            startitem = y->Parent;
            delete y;
        }
    }
    startitem->RestructureDelete();
    Tree = Tree->GetRoot();
    return true;
};

template <class T>
CAVLNode<T>* CAVLTree<T>::Search(const T* data)
{
    CAVLNode<T>* root = GetRoot();
    if (root==NULL)
        return NULL;
    return root->Search(data);
};

template <class T>
CAVLNode<T>* CAVLTree<T>::Search(T& data)
{
    CAVLNode<T>* root = GetRoot();
    if (root==NULL)
        return NULL;
    return root->Search(&data);
};

template <class T>
CAVLNode<T>* CAVLTree<T>::GetRoot()
{
    return Tree;
};

template <class T>
long CAVLTree<T>::NodesInTree() const
{
    if (Tree)
        return Tree->NodesInTree();
    return 0;
};

template <class T>
bool CAVLNode<T>::CheckBalances(const char * buffer, unsigned int buflen) const
{
    int d1 = 0;
    int d2 = 0;
    if (Left)
    {
        d1 = Left->GetDepth();
        if (!Left->CheckBalances(buffer, buflen)) return false;
    }
    if (Right)
    {
        d2 = Right->GetDepth();
        if (!Right->CheckBalances(buffer, buflen)) return false;
    }
    if (abs(d1-d2)>1)
    {
        if (buffer)
            sprintf(buffer, "Depths are incorrect for AVL-Tree (Left %d, Right %d), level: %d", d1, d2, GetLevel());
        return false;
    }
    if (Balance == -1 && d1 >  d2) return true;
    if (Balance ==  0 && d1 == d2) return true;
    if (Balance ==  1 && d1 <  d2) return true;
    if (buffer)
        sprintf(buffer, "Balance does not match depths: (Left %d, Right %d, Balance %d), level: %d", d1, d2, Balance, GetLevel());
    return false;
};

template <class T>
bool CAVLTree<T>::DeleteAll()
{
    delete Tree;
    Tree = NULL;
    return true;
};

template <class T>
bool CAVLTree<T>::Delete(CAVLTreeIterator<T>& iter, bool movenext)
{
    if (!iter)
        return false;
    CAVLNode<T>* item = iter.Current;
    CAVLNode<T>* item1 = NULL;
    if (movenext)
    {
        item1 = item->GetPrevNodeInOrder();
        iter.MoveNext();
    }
    else
    {
        item1 = item->GetNextNodeInOrder();
        iter.MovePrev();
    }
    T* t = (iter ? iter.Current->Data : NULL);
    bool ret = Delete(item->Data);
    if (t)
    {
        iter.Current = Search(t);
    }
    iter.Tree = NULL;
    if (iter.Current != NULL)
        iter.Tree = iter.Current->GetRoot();
    if (iter.Current == NULL && item1 != NULL)
        iter.Tree = item1->GetRoot();
    return ret;
};

#ifdef _MSC_VER
template <class T>
void CAVLTree<T>::Draw(CDC* dc, CRect& rect)
{
    if (IsEmpty()) return;
    Tree->Draw(dc, rect);
};
#endif

////////////////////////////////////////////////////////////////
// Iterator durch einen AVL-Baum                              //
////////////////////////////////////////////////////////////////
template <class T>
class CAVLTreeIterator
{
public:
    // construction and destruction
    // Konstruktor und Destruktor
    CAVLTreeIterator(CAVLNode<T>* tree);
    CAVLTreeIterator(CAVLTree<T>& tree);
    virtual ~CAVLTreeIterator();

    // validity
    // G?ltigkeitspr?fung
    operator bool();

    // navigation
    // Navigation
    void operator ++();
    void operator --();
    void operator ++(int);
    void operator --(int);
    void Reset();
    void MoveFirst();
    void MoveLast();
    void MoveNext();
    void MovePrev();

    // access to current node
    // Zugriff auf aktuellen Knoten
    T* GetData();
    CAVLNode<T>* Current;
private:
    CAVLNode<T>* Tree;
    CAVLTreeIterator(const CAVLTreeIterator<T>& /*treeiterator*/) {};
    CAVLTreeIterator& operator= (const CAVLTreeIterator<T>& /*treeiterator*/) {return *this;};

    friend class CAVLTree<T>;
};

template <class T>
CAVLTreeIterator<T>::CAVLTreeIterator(CAVLNode<T>* tree)
    : Tree(tree)
{
    if (Tree != NULL)
        Current = Tree->GetFirstNodeInOrder();
    else
        Current = NULL;
};

template <class T>
CAVLTreeIterator<T>::CAVLTreeIterator(CAVLTree<T>& tree)
    : Tree(tree.Tree)
{
    if (Tree != NULL)
        Current = Tree->GetFirstNodeInOrder();
    else
        Current = NULL;
};

template <class T>
CAVLTreeIterator<T>::~CAVLTreeIterator()
{
};

template <class T>
void CAVLTreeIterator<T>::Reset()
{
    if (Tree)
        Current = Tree->GetFirstNodeInOrder();
    else
        Current = NULL;
};

template <class T>
void CAVLTreeIterator<T>::MoveFirst()
{
    if (Tree)
        Current = Tree->GetFirstNodeInOrder();
    else
        Current = NULL;
};

template <class T>
void CAVLTreeIterator<T>::MoveLast()
{
    if (Tree)
        Current = Tree->GetLastNodeInOrder();
    else
        Current = NULL;
};

template <class T>
CAVLTreeIterator<T>::operator bool()
{
    return Current != NULL;
};

template <class T>
void CAVLTreeIterator<T>::operator ++()
{
    if (Current == NULL) return;
    Current = Current->GetNextNodeInOrder();
};

template <class T>
void CAVLTreeIterator<T>::operator --()
{
    if (Current == NULL) return;
    Current = Current->GetPrevNodeInOrder();
};

template <class T>
void CAVLTreeIterator<T>::operator ++(int)
{
    if (Current == NULL) return;
    Current = Current->GetNextNodeInOrder();
};

template <class T>
void CAVLTreeIterator<T>::operator --(int)
{
    if (Current == NULL) return;
    Current = Current->GetPrevNodeInOrder();
};

template <class T>
void CAVLTreeIterator<T>::MoveNext()
{
    if (Current == NULL) return;
    Current = Current->GetNextNodeInOrder();
};

template <class T>
void CAVLTreeIterator<T>::MovePrev()
{
    if (Current == NULL) return;
    Current = Current->GetPrevNodeInOrder();
};

template <class T>
T* CAVLTreeIterator<T>::GetData()
{
    if (Current)
        return Current->Data;
    else
        return NULL;
};

/* Code kann bei entsprechender Resourcen-Definition wieder eingesetzt
   werden, siehe Projekt ?????
template <class T>
class CAVLTreeDialog : public CDialog
{
public:
    CAVLTreeDialog(CAVLTree<T>& tree, CWnd* pParent = NULL);   // standard constructor

// Dialog Data
    enum { IDD = IDD_VEKTORTREEDIALOG1 };
    CTreeCtrl   m_Tree;


// Overrides
    protected:
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support

// Implementation
protected:
    CAVLTree<T>& Tree;
    CImageList  m_ctlImage;

    virtual BOOL OnInitDialog();
    virtual void Insert(CAVLNode<T>* item, HTREEITEM pos);
};

template <class T>
CAVLTreeDialog<T>::CAVLTreeDialog(CAVLTree<T>& tree, CWnd* pParent)
    : CDialog(CTreeDialog::IDD, pParent), Tree(tree)
{
};

template <class T>
void CAVLTreeDialog<T>::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
    DDX_Control(pDX, IDC_TREE1, m_Tree);
};

template <class T>
BOOL CAVLTreeDialog<T>::OnInitDialog()
{
    bool ret = CDialog::OnInitDialog();
    m_ctlImage.Create(IDB_BITMAP1,16,0,RGB(255,0,255));
    m_ctlImage.SetBkColor(GetSysColor(COLOR_WINDOW));
    m_Tree.SetImageList(&m_ctlImage, TVSIL_NORMAL);

    Insert(Tree.Tree, TVI_ROOT);
    return ret;
};

template <class T>
void CAVLTreeDialog<T>::Insert(CAVLNode<T>* tree, HTREEITEM pos)
{
    if (tree == NULL)
    {
        m_Tree.InsertItem(_T("NULL"), 3, 3, pos);
        return;
    }
    int image = 1 + tree->Balance;
    HTREEITEM newpos = m_Tree.InsertItem(*(tree->Data), image, image, pos);
    Insert(tree->Left, newpos);
    Insert(tree->Right, newpos);
};
*/
#endif // __AVL_TREE_H__


 

平衡二叉树（AVL tree）概述
qq_32164245的博客
05-31 2340
一、AVL tree基本概念AVL树前提是一种二叉排序树，其中每一个节点的左子树和右子树的高度差至多等于1。平衡因子BF（balance Factor）：二叉树结点的左子树深度与右子树深度的值，AVL树上所有节点的BF只能是-1、0、1，如果二叉树上有一个节点的BF的绝对值大于1，那么这个二叉树就是不平衡的。最小不平衡子树：距离插入节点最近的，且平衡因子的绝对值大于1的结点为根的子树，被称为最小不...
AVL树-自平衡二叉查找树(Java实现)
热门推荐
且行且码且思且娱
06-07 1万+
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。AVL树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis，他们在 1962 年的论文 "An algorithm for the organization of information" 中发表了它。 一、AVL树的旋转规律       AVL树的基本操作一般涉及运做同在不平衡的二叉查找树所运做的同样的算
『数据结构与算法』AVL树（平衡二叉树）
人生就是一个不断学习的过程
12-20 1654
GitHub源码分享 微信搜索：码农StayUp 主页地址：https://gozhuyinglong.github.io 源码分享：https://github.com/gozhuyinglong/blog-demos 1. AVL树 AVL（Adelson-Velskii 和 Landis）树是带有平衡条件的二叉查找树，又叫做平衡二叉树。在AVL树中任何节点的两个子树高度差最多为1，所以它又被称为高度平衡树。 如下图中可以清晰的看出，左边的树其根节点左子树高度为3，右子树高度为2，符合AVL树的特.
Balance Rotations of AVL Trees ：AVL树的平衡
yoyo_hu的博客
03-02 303
一、实验名称：Balance Rotations of AVL Trees 二、实验目的： 熟练掌握AVL树的数据结构,结构的特点； 能够实现AVL树的基本操作：如插入，调整，遍历，求树高等 三、实验内容： An AVL tree is a binary search tree where every node in the tree has a balance factor of -1, 0 or +1. But any insertion into the AVL tree may cause vi
AVL Tree --平衡二叉树
Juicewyh的博客
11-11 3395
AVL Tree     1.AVL树本质上是一棵二叉搜索树     2.AVL树带有平衡条件：每个节点左右子树的高度之差（平衡因子）的绝对值最多为1。如果在任何时候他们相差多余1，则重新平衡以恢复此属性。查找，插入，删除，在平均和最差情况下都需要O（log n）的时间。   为什么有了二叉搜索树，还需要AVL树？     对于二叉搜索树，他的插入，查找，删除的平均时间都是O（log n...
AVLTree 平衡二叉树c++实现
06-26
AVL树是一种自平衡的二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis在1962年提出，因此得名AVL树。这种数据结构在查找、插入和删除操作上的平均时间复杂度都是O(log n)，这得益于其严格的平衡性质。AVL树的主要...
陈越、何钦铭-数据结构作业13：Root of AVL Tree平衡二叉树的根节点
05-03
An AVL tree is a self-balancing binary search tree. In an AVL tree, the heights of the two child subtrees of any node differ by at most one; if at any time they differ by more than one, rebalancing is...
AVL tree 平衡二叉树
03-17
AVL tree的数据结构例程，参考《数据结构与算法分析——C语言版》，书上代码整理成为一个可运行C程序文件
pinghen.rar_avl_avl tree_balanced tree_二叉树_平衡二叉树
09-24
平衡二叉树（Balanced Binary Tree）是一种特殊的二叉树数据结构，它的主要特性在于保持了树的高度平衡。这种平衡状态使得在二叉查找树（Binary Search Tree, BST）中的操作，如插入、删除和搜索等，都能在对数时间...
03平衡二叉树_AVLTree.rar_03平衡二叉树_AVLTree_大话数据结构_平衡二叉树
09-21
在"03平衡二叉树_AVLTree.c"这个文件中，应该包含了C语言实现AVL树的代码，包括节点结构定义、插入、删除和查找等基本操作，以及相应的旋转函数。通过阅读和理解这段代码，可以深入学习AVL树的内部工作原理和操作...
平衡搜索树——AVLTree
王洋的博客
07-28 563
AVLTree 平衡搜索树：AVL树又称为高度平衡的二叉搜索树 性质： 1. 左子树和右子树的高度之差的绝对值不超过1 2. 树中的每个左子树和右子树都是AVL树 3. 每个节点都有一个平衡因子(balance factor–bf),任一节点的平衡因子是-1,0,1。(每个节点的平衡因子等于右子树的高度减去左子树的高度) 4.左孩子的值&amp;amp;lt;父节点&amp;amp;...
数据结构实验之查找二：平衡二叉树
Code_KK的博客
12-04 758
数据结构实验之查找二：平衡二叉树 Time Limit: 400MS Memory limit: 65536K 题目描述 根据给定的输入序列建立一棵平衡二叉树，求出建立的平衡二叉树的树根。 输入 输入一组测试数据。数据的第1行给出一个正整数N(n 输出 输出平衡二叉树的树根。 示例输入 5 88 7
手把手教你实现AVL树、平衡二叉树
weixin_61857742的博客
04-07 1839
今天，小编带大家一起来学习平衡二叉树（AVL树）吧。以下就简称AVL树了。 想必能点开这篇博客的朋友都是极度深爱计算机的，那今天就让我们一起揭开AVL树的神秘面纱吧！ 目录 一.基本概念 二.实现原理 （一）插入左子树 ①插入左子节点 ②插入右子节点 （二）插入右子树 ①插入右子节点 ②插入左子节点 （三）左旋转 （四）右旋转 三.代码实现 一.基本概念 AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. Landis。 AVL树是搜索二叉树的一
＜数据结构＞AVL树详解
weixin_63246064的博客
08-28 680
AVL树又叫平衡树(Balance_Tree)，笔者认为这个名字非常不错，中国嘛，就是在意阴阳平衡，之前小编还拿这个当过自己网络IP，哈哈哈。
MIT：算法导论——10.平衡搜索树-红黑树
loveprogram_1的专栏
06-15 853
【红黑树】是一棵二叉搜索树，它在每个结点上增加了一个存储位来表示结点的【颜色】， 可以是RED或BLACK。红黑树保证没有一条路径会比其他路径长出2倍，因而是近似【平衡】的。 【树中结点的5个属性】color、key、left、right和p。 一棵红黑树满是足下面【红黑性质】的二叉搜索树： （1）每个结点是红色或是黑色。 （2）根结点和每个叶节点（NIL）是黑色的。 （3）每个红色结
AVLTree
Liudengdeng_的博客
04-12 1571
左单旋：思路：1、创建节点subR和subRL2、parent的右指向subRL3、判断subRL是否存在      若存在，subRL的父亲就是parent      若不存在，也不影响4、subR的左指向parent      那么subR的父亲就是parent的父亲了5、给parent的父亲创建一个节点ppNode      parent的父亲也就是ppNode,也就是subR6、如果ppN...
平衡二叉树（AVL Tree）（c 语言 + 源代码）笔记
qq_22613757的博客
12-12 559
写在前面 最近写东西用到了平衡二叉树，借机钻研学习一下。 概念 平衡二叉查找树，也被称为高度平衡树。相比于“二叉查找树”，它的特点为： AVL树中任何结点的两个子树的高度最大差为1。 AVL 树的查找、插入和删除在平均和最坏情况下都是O（logn）。 对AVL树插入或删除操作时，会破坏AVL树的平衡状态。为了将其重新维持平衡，需要对其进行旋转处理。旋转算法很重要！！ AVL树的实现 头...
c/c++ AVLTree 平衡二叉树
旋律的博客
09-16 373
c/c++ 算法 二叉树 平衡二叉树
C 语言实现 AVL 树
SauryN的博客
08-30 2367
一、平衡二叉树简介     平衡二叉树又称 AVL树，其具有如下两个性质： 必须是二叉树； 必须是一颗空树或者其左右子树的高度只差不超过 1。     平衡二叉树的实现主要是为了避免普通二叉查找树在极端情况下（全部节点只有左孩子或者全部节点只有右孩子）会像链表那样影响性能。 二、AVL树 自平衡 #include <stdio.h> #include <stdlib.h> #include <string.h> #include "AVLTree.h" #defi
avltree 判断二叉树是否平衡
最新发布
03-09
好的，我需要回答如何检查AVL树是否平衡的问题。首先，AVL树的平衡条件是每个节点的左右子树高度差不超过1。所以，检查平衡的方法应该围绕这一点展开。 我应该先回忆AVL树的定义。根据引用[4]，AVL树要求每个节点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值