2. 程式人生 > >資料結構開發(25)：二叉樹中屬性操作、層次遍歷與典型遍歷

資料結構開發(25)：二叉樹中屬性操作、層次遍歷與典型遍歷

阿新 • • 發佈：2018-12-23

0.目錄

1.二叉樹的比較與相加

2.二叉樹的線索化實現

3.二叉樹的經典面試題分析

4.小結

1.二叉樹的比較與相加

二叉樹的克隆操作：

  • SharedPointer< BTree<T> > clone() const
    1. 克隆當前樹的一份拷貝
    2. 返回值為堆空間中的一棵新二叉樹 ( 與當前樹相等 )

二叉樹的克隆：

  • 定義功能：clone(node)
    1. 拷貝 node 為根結點的二叉樹 ( 資料元素在對應位置相等 )

在BTree.h中實現二叉樹的克隆操作：

protected:
    BTreeNode<T>* clone(BTreeNode<T>* node) const
    {
        BTreeNode<T>* ret = NULL;

        if( node != NULL )
        {
            ret = BTreeNode<T>::NewNode();

            if( ret != NULL )
            {
                ret->value = node->value;

                ret->left = clone(node->left);
                ret->right = clone(node->right);

                if( ret->left != NULL )
                {
                    ret->left->parent = ret;
                }

                if( ret->right != NULL )
                {
                    ret->right->parent = ret;
                }
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new node ...");
            }
        }

        return ret;
    }
public:
    SharedPointer< BTree<T> > clone() const
    {
        BTree<T>* ret = new BTree<T>();

        if( ret != NULL )
        {
            ret->m_root = clone(root());
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new tree ...");
        }

        return ret;
    }

二叉樹比較操作的定義：

  • 判斷兩棵二叉樹中的資料元素是否對應相等
    1. bool operator == (const BTree<T>& btree)
    2. bool operator != (const BTree<T>& btree)

二叉樹的比較：

  • 定義功能：equal(lh, rh)
    1. 判斷 Ih 為根結點的二叉樹與 rh 為根結點的二叉樹是否相等

在BTree.h中實現二叉樹的比較操作：

protected:
    bool equal(BTreeNode<T>* lh, BTreeNode<T>* rh) const
    {
        if( lh == rh )
        {
            return true;
        }
        else if( (lh != NULL) && (rh != NULL) )
        {
            return (lh->value == rh->value) && equal(lh->left, rh->left) && equal(lh->right, rh->right);
        }
        else
        {
            return false;
        }
    }
public:
    bool operator == (const BTree<T>& btree)
    {
        return equal(root(), btree.root());
    }

    bool operator != (const BTree<T>& btree)
    {
        return !(*this == btree);
    }

統一mian.cpp測試：

#include <iostream>
#include "BTree.h"

using namespace std;
using namespace StLib;

int main()
{
    BTree<int> bt;
    BTreeNode<int>* n = NULL;

    bt.insert(1, NULL);

    n = bt.find(1);
    bt.insert(2, n);
    bt.insert(3, n);

    n = bt.find(2);
    bt.insert(4, n);
    bt.insert(5, n);

    n = bt.find(4);
    bt.insert(8, n);
    bt.insert(9, n);

    n = bt.find(5);
    bt.insert(10, n);

    n = bt.find(3);
    bt.insert(6, n);
    bt.insert(7, n);

    SharedPointer< BTree<int> > btClone = bt.clone();

    int a[] = {8, 9, 10, 6, 7};

    cout << "Clone: " << endl;
    for(int i=0; i<5; i++)
    {
        TreeNode<int>* node = btClone->find(a[i]);

        while( node )
        {
            cout << node->value << " ";
            node = node->parent;
        }
        cout << endl;
    }
    cout << endl;

    cout << "Old BTree: " << endl;
    for(int i=0; i<5; i++)
    {
        TreeNode<int>* node = bt.find(a[i]);

        while( node )
        {
            cout << node->value << " ";
            node = node->parent;
        }
        cout << endl;
    }
    cout << endl;

    cout << "bt == *btClone : " << (bt == *btClone) << endl;

    return 0;
}

執行結果為：

Clone: 
8 4 2 1 
9 4 2 1 
10 5 2 1 
6 3 1 
7 3 1 

Old BTree: 
8 4 2 1 
9 4 2 1 
10 5 2 1 
6 3 1 
7 3 1 

bt == *btClone : 1

二叉樹的相加操作：

  • SharedPointer< BTree<T> > add(const BTree<T>& btree) const
    1. 將當前二叉樹與引數 btree 中的資料元素在對應位置處相加
    2. 返回值 ( 相加的結果 ) 為堆空間中的一棵新二叉樹

二叉樹的加法：

  • 定義功能：add(Ih, rh)
    1. 將 Ih 為根結點的二叉樹與 rh 為根結點的二叉樹相加

在BTree.h中實現二叉樹的相加操作：

protected:
    BTreeNode<T>* add(BTreeNode<T>* lh, BTreeNode<T>* rh) const
    {
        BTreeNode<T>* ret = NULL;

        if( (lh == NULL) && (rh != NULL) )
        {
            ret = clone(rh);
        }
        else if( (lh != NULL) && (rh == NULL) )
        {
            ret = clone(lh);
        }
        else if( (lh != NULL) && (rh != NULL) )
        {
            ret = BTreeNode<T>::NewNode();

            if( ret != NULL )
            {
                ret->value = lh->value + rh->value;

                ret->left = add(lh->left, rh->left);
                ret->right = add(lh->right, rh->right);

                if( ret->left != NULL )
                {
                    ret->left->parent = ret;
                }

                if( ret->right != NULL )
                {
                    ret->right->parent = ret;
                }
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new node ...");
            }
        }

        return ret;
    }
public:
    SharedPointer< BTree<T> > add(const BTree<T>& btree) const
    {
        BTree<T>* ret = new BTree<T>();

        if( ret != NULL )
        {
            ret->m_root = add(root(), btree.root());
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new tree ...");
        }

        return ret;
    }

mian.cpp測試：

#include <iostream>
#include "BTree.h"

using namespace std;
using namespace StLib;

int main()
{
    BTree<int> bt;
    BTreeNode<int>* n = NULL;

    bt.insert(1, NULL);

    n = bt.find(1);
    bt.insert(2, n);
    bt.insert(3, n);

    n = bt.find(2);
    bt.insert(4, n);
    bt.insert(5, n);

    n = bt.find(4);
    bt.insert(8, n);
    bt.insert(9, n);

    n = bt.find(5);
    bt.insert(10, n);

    n = bt.find(3);
    bt.insert(6, n);
    bt.insert(7, n);


    BTree<int> nbt;

    nbt.insert(0, NULL);

    n = nbt.find(0);
    nbt.insert(6, n);
    nbt.insert(2, n);

    n = nbt.find(2);
    nbt.insert(7, n);
    nbt.insert(8, n);

    SharedPointer< BTree<int> > r = bt.add(nbt);

    int a[] = {8, 9, 10, 13, 5};

    cout << "Add result: " << endl;
    for(int i=0; i<5; i++)
    {
        TreeNode<int>* node = r->find(a[i]);

        while( node )
        {
            cout << node->value << " ";
            node = node->parent;
        }
        cout << endl;
    }
    cout << endl;

    SharedPointer< Array<int> > tr = r->traversal(PreOrder);

    cout << "先序遍歷：" << endl;
    for(int i=0; i<(*tr).length(); i++)
    {
        cout << (*tr)[i] << " ";
    }
    cout << endl;

    return 0;
}

執行結果為：

Add result: 
8 1 
9 4 8 1 
10 5 8 1 
13 5 1 
5 8 1 

先序遍歷：
1 8 4 8 9 5 10 5 13 15

2.二叉樹的線索化實現

什麼是線索化二叉樹？

  • 將二叉樹轉換為雙向連結串列的過程 ( 非線性 → 線性 )
  • 能夠反映某種二叉樹的遍歷次序 ( 結點的先後訪問次序 )
    1. 利用結點的 right 指標指向遍歷中的後繼結點
    2. 利用結點的 left 指標指向遍歷中的前驅結點

如何對二叉樹進行線索化？
思維過程：

二叉樹的線索化：

本節目標：

  • 新增功能函式 traversal(order, queue)
  • 新增遍歷方式 BTTraversal::LevelOrder
  • 新增公有函式 BTreeNode<T>* thread(BTTraversal order)
  • 消除遍歷和線索化的程式碼冗餘 ( 程式碼重構 )

層次遍歷演算法小結：

  1. 將根結點壓入佇列中
  2. 訪問隊頭元素指向的二叉樹結點
  3. 隊頭元素彈出，將隊頭元素的孩子壓入佇列中
  4. 判斷佇列是否為空 ( 非空：轉 2，空：結束 )

層次遍歷演算法示例：

函式介面設計：

  • BTreeNode<T>* thread(BTTraversal order)
    1. 根據引數 order 選擇線索化的次序 ( 先序，中序，後序，層次 )
    2. 返回值線索化之後指向連結串列首結點的指標
    3. 線索化執行結束之後對應的二叉樹變為空樹

線索化流程：

佇列中結點的連線演算法 [ connect(queue) ]：

列舉中加入層次遍歷：

enum BTTraversal
{
    PreOrder,
    InOrder,
    PostOrder,
    LevelOrder
};

二叉樹的線索化：

protected:
    void levelOrderTraversal(BTreeNode<T>* node, LinkQueue<BTreeNode<T>*>& queue) // 層次遍歷
    {
        if( node != NULL )
        {
            LinkQueue<BTreeNode<T>*> tmp;

            tmp.add(node);

            while( tmp.length() > 0 )
            {
                BTreeNode<T>* n = tmp.front();

                if( n->left != NULL )
                {
                    tmp.add(n->left);
                }

                if( n->right != NULL )
                {
                    tmp.add(n->right);
                }

                tmp.remove();
                queue.add(n);
            }
        }
    }
    void traversal(BTTraversal order, LinkQueue<BTreeNode<T>*>& queue)
    {
        switch (order)
        {
            case PreOrder:
                preOrderTraversal(root(), queue);
                break;
            case InOrder:
                inOrderTraversal(root(), queue);
                break;
            case PostOrder:
                postOrderTraversal(root(), queue);
                break;
            case LevelOrder:
                levelOrderTraversal(root(), queue);
                break;
            default:
                THROW_EXCEPTION(InvalidParameterException, "Parameter order is invalid ...");
                break;
        }
    }

    BTreeNode<T>* connect(LinkQueue<BTreeNode<T>*>& queue)
    {
        BTreeNode<T>* ret = NULL;

        if( queue.length() > 0 )
        {
            ret = queue.front();

            BTreeNode<T>* slider = queue.front();

            queue.remove();

            slider->left = NULL;

            while( queue.length() > 0 )
            {
                slider->right = queue.front();
                queue.front()->left = slider;
                slider = queue.front();
                queue.remove();
            }

            slider->right = NULL;
        }

        return ret;
    }
public:
    SharedPointer< Array<T> > traversal(BTTraversal order)
    {
        DynamicArray<T>* ret = NULL;
        LinkQueue<BTreeNode<T>*> queue;

        traversal(order, queue);

        ret = new DynamicArray<T>(queue.length());

        if( ret != NULL )
        {
            for(int i=0; i<ret->length(); i++, queue.remove())
            {
                ret->set(i, queue.front()->value);
            }
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create return array ...");
        }

        return ret;
    }

    BTreeNode<T>* thread(BTTraversal order)
    {
        BTreeNode<T>* ret = NULL;
        LinkQueue<BTreeNode<T>*> queue;

        traversal(order, queue);

        ret = connect(queue);

        this->m_root = NULL;

        m_queue.clear();

        return ret;
    }

main.cpp測試：

#include <iostream>
#include "BTree.h"

using namespace std;
using namespace StLib;

int main()
{
    BTree<int> bt;
    BTreeNode<int>* n = NULL;

    bt.insert(1, NULL);

    n = bt.find(1);
    bt.insert(2, n);
    bt.insert(3, n);

    n = bt.find(2);
    bt.insert(4, n);
    bt.insert(5, n);

    n = bt.find(4);
    bt.insert(8, n);
    bt.insert(9, n);

    n = bt.find(5);
    bt.insert(10, n);

    n = bt.find(3);
    bt.insert(6, n);
    bt.insert(7, n);

    SharedPointer< Array<int> > tr = bt.traversal(LevelOrder);

    for(int i=0; i<(*tr).length(); i++)
    {
        cout << (*tr)[i] << " ";
    }
    cout << endl;

    BTreeNode<int>* head = bt.thread(LevelOrder);

    while( head != NULL )
    {
        cout << head->value << " ";
        head = head->right;
    }
    cout << endl;

    return 0;
}

執行結果為：

1 2 3 4 5 6 7 8 9 10 
1 2 3 4 5 6 7 8 9 10

3.二叉樹的經典面試題分析

準備程式碼：

#include <iostream>
#include "BTree.h"

using namespace std;
using namespace StLib;

template < typename T >
BTreeNode<T>* createTree()
{
    static BTreeNode<int> ns[9];

    for(int i=0; i<9; i++)
    {
        ns[i].value = i;
        ns[i].parent = NULL;
        ns[i].left = NULL;
        ns[i].right = NULL;
    }

    ns[0].left = &ns[1];
    ns[0].right = &ns[2];
    ns[1].parent = &ns[0];
    ns[2].parent = &ns[0];

    ns[1].left = &ns[3];
    ns[1].right = NULL;
    ns[3].parent = &ns[1];

    ns[2].left = &ns[4];
    ns[2].right = &ns[5];
    ns[4].parent = &ns[2];
    ns[5].parent = &ns[2];

    ns[3].left = NULL;
    ns[3].right = &ns[6];
    ns[6].parent = &ns[3];

    ns[4].left = &ns[7];
    ns[4].right = NULL;
    ns[7].parent = &ns[4];

    ns[5].left = &ns[8];
    ns[5].right = NULL;
    ns[8].parent = &ns[5];

    return ns;
}

template < typename T >
void printInOrder(BTreeNode<T>* node)
{
    if( node != NULL )
    {
        printInOrder(node->left);

        cout << node->value <<" ";

        printInOrder(node->right);
    }
}

template < typename T >
void printDualList(BTreeNode<T>* node)
{
    BTreeNode<T>* g = node;

    cout << "head -> tail: " << endl;

    while( node != NULL )
    {
        cout << node->value << " ";

        g = node;

        node = node->right;
    }

    cout << endl;

    cout << "tail -> head: " << endl;

    while( g != NULL )
    {
        cout << g->value << " ";

        g = g->left;
    }

    cout << endl;
}

int main()
{
    BTreeNode<int>* ns = createTree<int>();

    printInOrder(ns);
    cout << endl;

    return 0;
}

執行結果為：

3 6 1 0 7 4 2 8 5

3.1 單度結點刪除

面試題一：

  • 單度結點刪除
    1. 編寫一個函式用於刪除二叉樹中的所有單度結點
    2. 要求：結點刪除後，其唯一的子結點替代它的位置

結點中包含指向父結點的指標：

  • 定義功能：delOdd1(node)
    1. 刪除 node 為根結點的二叉樹中的單度結點

單度結點刪除（結點中包含指向父結點的指標）：

template < typename T >
BTreeNode<T>* delOdd1(BTreeNode<T>* node)
{
    BTreeNode<T>* ret = NULL;

    if( node != NULL )
    {
        if(((node->left != NULL) && (node->right == NULL)) ||
           ((node->left == NULL) && (node->right != NULL)) )
        {
            BTreeNode<T>* parent = dynamic_cast<BTreeNode<T>*>(node->parent);
            BTreeNode<T>* node_child = (node->left != NULL) ? node->left : node->right;

            if( parent != NULL )
            {
                BTreeNode<T>*& parent_child = (parent->left == node) ? parent->left : parent->right;

                parent_child = node_child;
                node_child->parent = parent;
            }
            else
            {
                node_child->parent = NULL;
            }

            if( node->flag() )
            {
                delete node;
            }

            ret = delOdd1(node_child);
        }
        else
        {
            delOdd1(node->left);
            delOdd1(node->right);

            ret = node;
        }
    }

    return ret;
}

int main()
{
    BTreeNode<int>* ns = createTree<int>();

    printInOrder(ns);
    cout << endl;

    ns = delOdd1(ns);

    printInOrder(ns);
    cout << endl;

    int a[] = {6, 7, 8};
    for(int i=0; i<3; i++)
    {
        TreeNode<int>* n = ns + a[i];

        while( n != NULL )
        {
            cout << n->value << " ";

            n = n->parent;
        }
        cout << endl;
    }

    return 0;
}

執行結果為：

3 6 1 0 7 4 2 8 5 
6 0 7 2 8 
6 0 
7 2 0 
8 2 0

結點中只包含左右孩子指標：

  • 定義功能：delOdd2(node) // node為結點指標的引用
    1. 刪除 node 為根結點的二叉樹中的單度結點

單度結點刪除（結點中只包含左右孩子指標）：

template < typename T >
void delOdd2(BTreeNode<T>*& node)
{
    if( node != NULL )
    {
        if(((node->left != NULL) && (node->right == NULL)) ||
           ((node->left == NULL) && (node->right != NULL)) )
        {
            BTreeNode<T>* node_child = (node->left != NULL) ? node->left : node->right;

            if( node->flag() )
            {
                delete node;
            }

            node = node_child;

            delOdd2(node);
        }
        else
        {
            delOdd2(node->left);
            delOdd2(node->right);
        }
    }
}

int main()
{
    BTreeNode<int>* ns = createTree<int>();

    printInOrder(ns);
    cout << endl;

    delOdd2(ns);

    printInOrder(ns);
    cout << endl;

    return 0;
}

執行結果為：

3 6 1 0 7 4 2 8 5 
6 0 7 2 8

3.2 中序線索化二叉樹

面試題二：

  • 中序線索化二叉樹
    1. 編寫一個函式用於中序線索化二叉樹
    2. 要求：不允許使用其它資料結構

解法一：在中序遍歷的同時進行線索化

  • 思路：
    1. 使用輔助指標，在中序遍歷時指向當前結點的前驅結點
    2. 訪問當前結點時，連線與前驅結點的先後次序

定義功能：inOrderThread(node, pre)

  • node：根結點，也是中序訪問的結點
  • pre：為中序遍歷時的前驅結點指標

中序線索化二叉樹：

template < typename T >
void inOrderThread(BTreeNode<T>* node, BTreeNode<T>*& pre)
{
    if( node != NULL )
    {
        inOrderThread(node->left, pre);

        node->left = pre;

        if( pre != NULL )
        {
            pre->right = node;
        }

        pre = node;

        inOrderThread(node->right, pre);
    }
}

template < typename T >
BTreeNode<T>* inOrderThread1(BTreeNode<T>* node)
{
    BTreeNode<T>* pre = NULL;

    inOrderThread(node, pre);

    while( (node != NULL) && (node->left != NULL) )
    {
        node = node->left;
    }

    return node;
}

int main()
{
    BTreeNode<int>* ns = createTree<int>();

    printInOrder(ns);
    cout << endl;

    delOdd2(ns);

    printInOrder(ns);
    cout << endl;

    ns = inOrderThread1(ns);

    printDualList(ns);

    return 0;
}

執行結果為：

3 6 1 0 7 4 2 8 5 
6 0 7 2 8 
head -> tail: 
6 0 7 2 8 
tail -> head: 
8 2 7 0 6

解法二：中序遍歷的結點次序正好是結點的水平次序

  • 思路：
    1. 使用輔助指標，指向轉換後雙向連結串列的頭結點和尾結點
    2. 根結點與左右子樹轉換的雙向連結串列連線，成為完整雙向連結串列

定義功能：inOrderThread(node, head, tail)

  • node：根結點，也是中序訪問的結點
  • head：轉換成功後指向雙向連結串列的首結點
  • tail：轉換成功後指向雙鏈表的尾結點

中序線索化二叉樹：

template < typename T >
void inOrderThread(BTreeNode<T>* node, BTreeNode<T>*& head, BTreeNode<T>*& tail)
{
    if( node != NULL )
    {
        BTreeNode<T>* h = NULL;
        BTreeNode<T>* t = NULL;

        inOrderThread(node->left, h, t);

        node->left = t;

        if( t != NULL )
        {
            t->right = node;
        }

        head = (h != NULL) ? h : node;

        h = NULL;
        t = NULL;

        inOrderThread(node->right, h, t);

        node->right = h;

        if( h != NULL )
        {
            h->left = node;
        }

        tail = (t != NULL) ? t : node;
    }
}

template < typename T >
BTreeNode<T>* inOrderThread2(BTreeNode<T>* node)
{
    BTreeNode<T>* head = NULL;
    BTreeNode<T>* tail = NULL;

    inOrderThread(node, head, tail);

    return head;
}

int main()
{
    BTreeNode<int>* ns = createTree<int>();

    printInOrder(ns);
    cout << endl;

    ns = inOrderThread2(ns);

    printDualList(ns);

    return 0;
}

執行結果為：

3 6 1 0 7 4 2 8 5 
head -> tail: 
3 6 1 0 7 4 2 8 5 
tail -> head: 
5 8 2 4 7 0 1 6 3

4.小結

  • 比較操作判斷兩棵二叉樹中的資料元素是否對應相等
  • 克隆操作將當前二叉樹在堆空間中進行復制
  • 相加操作將兩棵二叉樹中的資料元素在對應位置處相加
  • 相加操作的結果儲存在堆空間的一棵二叉樹中
  • 線索化是將二叉樹轉換為雙向連結串列的過程
  • 線索化之後結點間的先後次序符合某種遍歷次序
  • 線索化操作將破壞原二叉樹結點間的父子關係
  • 線索化之後二叉樹將不再管理結點的生命期

相關推薦

資料結構開發(25)：二叉樹中屬性操作、層次遍歷與典型遍歷

0.目錄 1.二叉樹的比較與相加 2.二叉樹的線索化實現 3.二叉樹的經典面試題分析 3.1 單度結點刪除 3.2 中序線索化二叉樹 4.小結 1.二叉樹的比較與相加 二叉樹的克隆操作： SharedPointer< BTree<T> > clone

資料結構開發(24)：二叉樹中屬性操作、層次遍歷與典型遍歷

0.目錄 1.二叉樹中屬性操作的實現 2.二叉樹結構的層次遍歷 3.二叉樹的典型遍歷方式 4.小結 1.二叉樹中屬性操作的實現 二叉樹的屬性操作： 二叉樹中結點的數目： 定義功能：count(node) 在 node 為根結點的二叉樹中統計結點數目 在

資料結構開發(23)：二叉樹中結點的查詢、插入、刪除與清除操作

0.目錄 1.二叉樹中結點的查詢操作 2.二叉樹中結點的插入操作 3.二叉樹中結點的刪除操作 4.二叉樹中結點的清除操作 5.小結 1.二叉樹中結點的查詢操作 查詢的方式： 基於資料元素值的查詢 BTreeNode<T>* find(const T&

資料結構 筆記：二叉樹中屬性操作的實現

二叉樹的屬性操作 count() = 10; height() = 4; degree() = 2; 二叉樹結點的數目 -定義功能：count(node) ·在node為根結點的二叉樹中統計結點數目 int count(BTreeNode<T>* nod

數據結構開發(22)：二叉樹的轉換、深層特性與存儲結構設計

his 9.png 二叉 klist efi remove ren binary 兩個 0.目錄 1.樹到二叉樹的轉換 2.二叉樹的深層特性 3.二叉樹的存儲結構設計 4.小結 1.樹到二叉樹的轉換 通用樹結構的回顧： 雙親孩子表示法 每個結點都有一個指向其雙親的指針

資料結構和演算法：二叉樹

二叉樹 二叉樹（Binary tree）是樹形結構的一個重要型別。許多實際問題抽象出來的資料結構往往是二叉樹形式，即使是一般的樹也能簡單地轉換為二叉樹，而且二叉樹的儲存結構及其演算法都較為簡單，因此二叉樹顯得特別重要。二叉樹特點是每個節點最多隻能有兩棵子樹，即樹的度最大為2，且有左右之分 。 二叉樹是n個有限

資料結構實驗3《二叉樹的基本操作》

根據輸入的資料建立一個二叉樹；分別採用前序、中序、後序的遍歷方式顯示輸出二叉樹的遍歷結果程式碼：#include<iostream> using namespace std; struct

資料結構 筆記：二叉樹中的結點刪除與清除

刪除的方式 -基於資料元素值的刪除 ·SharedPointer<Tree<T>>remove(const T& value) -基於結點的刪除 ·SharedPointer<Tree <T>>remove(TreeNode&l

資料結構 筆記：二叉樹中的結點插入操作

是否能夠在二叉樹的而已結點出插入子結點？ -不能，二叉樹結點的每個結點的子結點是固定的，只存在左孩子和右孩子. 是否需要指定新資料元素（新結點）的插入位置？ -需要指定為左孩子或者右孩子 enum BTNodePos { ANY, LEFT, RIGHT };

資料結構 筆記：二叉樹中的結點查詢操作

查詢的方式 -基於資料元素值的查詢 ·BTreeNode<T>* find(const T& value) const -基於結點的查詢 ·BTreeNode<T>* find(TreeNode<T>* node) const 基於資料

【資料結構】BST：二叉排序樹演算法

建立二叉排序樹，實現樹的插入、刪除，前、中、後序遍歷（遞迴方式）等操作。 /***************************************** Copyright (c) 2015 Jingshuang Hu @filename:dem

基本數據結構學習總結： 二叉樹的遍歷

root 取出 後序 二叉 isnull 就是 bre 遞歸 use 二叉搜索樹的遍歷 二叉樹遍歷的內容很多，但是也是最重要的，最需要理解的，很多二叉樹的相關算法，只要用活了遍歷就沒有問題了 前序遍歷 對於每一棵樹，先遍歷其根節點，然後遍歷其左子樹，最後用同樣的方式遍歷

資料結構——4.2 平衡二叉樹

搜尋樹結點不同的插入次序，將導致不同的深度和平均查詢長度ASL 平衡因子：BF（T）=hL-hR，其中hL和hR分別為T的左右子樹的高度。 平衡二叉樹（AVL樹）：是一個空樹或者 要求任一結點左右子樹高度差的絕對值小於等於1，即|BF(T)| <=1 設nh為 高度是h

資料結構之－平衡二叉樹(AVL)

背景 不同結構的二叉查詢樹，查詢效率有很大的不同。如何解決這個問題呢？關鍵在於如何最大限度的減小樹的深度。正是基於這個想法，平衡二叉樹出現了。 前言 平衡二叉搜尋樹（英語：Balanced Binary Tree）是一種結構平衡的二叉搜尋樹。 它能在O(log n)時間內完成插入、查詢和

【資料結構】3-1 二叉樹的先序建立及遍歷操作

二叉樹真的令人頭大 #include<iostream> using namespace std; template <class T> struct BTNode//二叉連結串列結點結構 { T data; //二叉樹中的元素 BTNode<T>

資料結構——鏈佇列實現二叉樹的層次遍歷

在二叉樹的遍歷這篇部落格中https://www.cnblogs.com/wkfvawl/p/9901462.html 對於二叉樹的層次遍歷我只是給出了基於C++ STL的程式碼，這裡我使用資料結構的連結串列，構建一個鏈佇列來實現。這也算是我第一次使用鏈佇列來完成某個任務，鏈佇列程式碼還是來自課本，因為之前

資料結構實驗-C語言-二叉樹的建立，前、中、後序遍歷的遞迴演算法和非遞迴演算法，求葉子結點數目，求二叉樹深度，判斷二叉樹是否相似，求二叉樹左右子樹互換，二叉樹層序遍歷的演算法，判斷二叉樹是否是完全二叉樹

1.實驗目的 熟練掌握二叉樹的二叉連結串列儲存結構的C語言實現。掌握二叉樹的基本操作-前序、中序、後序遍歷二叉樹的三種方法。瞭解非遞迴遍歷過程中“棧”的作用和狀態，而且能靈活運用遍歷演算法實現二叉樹的其它操作。 2.實驗內容 （1）二叉樹的二叉連結串列的建立 （2）二叉樹的前、中、後

C語言複習資料結構之簡單的二叉樹輸入和輸出操作

C語言複習之簡單的二叉樹的僅輸入輸出操作 1：結構體 typedef struct TreeNode{ _Data value; struct TreeNode * father; struct TreeNode * right; stru

【資料結構學習筆記】二叉樹和其他樹

基礎定義 一個樹t是一個非空的有限元素的集合，其中一個元素為根（root），其餘的元素（如果有的話）組成t的子樹（subtree） 樹的另一常用術語為級（level）。樹根是1級，其孩子（如果有）是2級，孩子的孩子是3級，等等。 一棵樹的高度（height）或深度（de

劍指offer{面試題25：二叉樹中和為某一值的路徑}

思路：這道題比較有意思，類似的題我在面試裡經常遇到過，圍繞著樹的深度遍歷和廣度遍歷做文章，針對這種型別的題，大家更多考慮的解決方案是遞迴，說白了二叉樹就是一群小二叉樹，上次做寶寶樹的筆試題的時候，出的演算法題就是求任意兩個節點之間的最遠距離，說白了還是遍歷的問題，回到這道題  &n