二叉查找树全面详细介绍

最新推荐文章于 2022-03-05 19:01:50 发布
最新推荐文章于 2022-03-05 19:01:50 发布
阅读量1.8k 收藏 9
点赞数 2
分类专栏： # 数据结构——树 文章标签： 数据结构 二叉树 非递归遍历实现 Morris遍历实现
转载请标明出处
本文链接：https://blog.csdn.net/nie2314550441/article/details/107030025
版权

一、前言

重新梳理整理归纳二叉搜索树。主要参考《C++数据结构与算法》。

 

二、定义

二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。是数据结构中的一类。在一般情况下，查询效率比链表结构要高。

二叉排序树定义，一棵空树，或者是具有下列性质的二叉树：

  1. 若左子树不空，则左子树上所有结点的值均小于它的根结点的值；
  2. 若右子树不空，则右子树上所有结点的值均大于它的根结点的值；
  3. 左、右子树也分别为二叉排序树；
  4. 没有键值相等的结点。

 

三、二叉搜索树接口操作说明

二叉搜索树的基本操作有：搜索（查找）、遍历、插入、删除。

3.1 搜索

在树中定位一个元素的算法相当直观，《4.2 搜索（查找）》实现了该算法。对于每个节点，算法将要定位的值与当前所指节点中存储的值进行比较。如果该值小于存储值，则转向左子树；如果该值大于存储的值，则转向右子树。如果二者相同，很明显查找过程可以结束了。如果没有其他可以查找的节点，该查找过程也终止，这表示该值不在该树中。

搜索实现方法可以分为：递归搜索、非递归搜索《4.2 搜索（查找）》实现了该算法。

 

3.2 遍历

树的遍历是当且仅当访问树中每个节点一次的过程。遍历可以解释为把所有的节点放在一条线上,或者将树线性化。

遍历的定义只指定了个条件：每个节点仪访问一次，没有指定这些节点的访问顺序。因此，节点有多少种排列方式，就有多少种遍历方法。对于有n个节点的树，共有n!个不同的遍历方式。然而，大多数遍历方式是混乱的，很难从中找到规律，因此实现这样的遍历缺乏普遍性。对于每个n，必须实现一套独立的遍历程序，其中只有很少的几个可以用于不同数量的数据。在如此多的遍历方法中，大多数方法明显没有什么用处，这里仅介绍两类方法，即深度优先遍历与广度优先遍历。

遍历可以分为：深度优先遍历(DFS)和广度优先遍历(BFS)。

3.2.1 深度优先遍历(DFS)

深度优先遍历将尽可能地向左(或向右)进行，在遇到第一个转折点时，向左(或向右)一步，然后,再尽可能地向左(或向右)发展。这一过程，一直重复，直至访问了所有的节点为止。然而，这一定义并没有清楚地指明什么时候访问节点：在沿着树向下进行之前还是在折返之后？深度优先遍历有许多变种。

这种类型的遍历中，有3个有趣的任务：

  • v——访问节点
  • L——遍历左子树
  • R——遍历右子树

如果这些任务在每个节点上都以相同的顺序执行，就形成了有序遍历。这3种任务自身共有3!=6种排序方式，因此，总共有6种有序深度优先遍历：VLR，LVR，LRV，VRL，RVL，RLV。

遍历方式看起来还是有些多，如果规定访问总是从左向右移动，则上面的遍历方式可以缩减为3种。这三种遍历方式的标准名称为：

  • VLR——前序树遍历
  • LVR——中字树遍历
  • LVR——后序树遍

深度优先遍历(DFS)按照遍历顺序可以分为：前序遍历、中序遍历、后序遍历

深度优先遍历(DFS)按照实现方法可以分为：递归遍历实现、非递归遍历实现、Morris遍历实现。

深度优先遍历接口有9(3*3)个。

备注：递归遍历实现、非递归遍历实现、Morris遍历实：详细讲解：https://blog.csdn.net/nie2314550441/article/details/107073598

 

3.2.2 广度优先遍历(BFS)

用队列实现。《4.5 插入》实现了插入节点算法的代码。

广度优先遍历从最低层(或者最高层)开始，向下(或向上)逐层访问每个节点，在每一层次上，从左到右(或从右到左)访问每个节点。这样就有4种访问方式，其中的种访问方式(从上到下、从左到右的广度优先遍历方式)。

当使用队列时，这种遍历方式的实现相当直接。假设从上到下、从左到右进行广度优先遍历。在访问了一个节点后，它的子节点(如果有的话)就放到队列的末尾，然后访问队列头部的节点。对于层次为n的节点，它的子节点位于第n+1层，如果将该节点的所有子节点都放到队列的末尾，那么，这些节点将在第n层的所有节点都访问后再访问。这样，算法就满足了“第n层的所有节点都必须在第n+1层的节点之前访问”的条件。实现过程见——4.4 广度优先遍历。

 

3.3 插入

要插入键值为el的新节点，必须找到树中的一个终端节点，并将新节点与该节点连接。要找到这样一个终端节点，可以使用与查找树相同的技术：在扫描树的过程中，比较键值el与当前检查的节点的键值。如果el小于该键值，就测试当前节点的左子节点，否则，就测试当前节点的右子节点。如果要测试的p的子节点为空，就停止扫描，新节点将成为p的子节点。图6-12显示了这一过程。

插入实现方法可以分为：非递归实现、递归实现。

 

3.4 删除

删除节点有两种方案：查找合并删除、查找复制删除。

执行删除操作的复杂度取决于要删除的节点在树中的位置。删除有两个子树的节点比删除叶节点困难得多，删除算法的复杂度与被删除节点的子节点数目成正比。从二叉查找树中删除节点有三种情况：

(1)要删除的节点是一个叶节点，该节点没有子节点。这种情况最容易处理。其父节点的相应指针设置为空，该节点通过delete操作被删除，如图6-14所示。

(2)要删除的节点有一个子节点，这种情况也不复杂。父节点中指向该节点的指针重新设置为指向被删除节点的子节点。这样，被删除节点的子节点提升一个层次，其后的所有后裔节点根据家族关系依次提升一个层次。例如，要删除图6-15中包含20的节点，可以将其父节点15的右指针指向其唯的子节点16。

(3)要删除的节点有两个子节点。在这种情况中，无法一步完成删除操作，因为父节点的右指针或左指针不能同时指向被删除节点的两个子节点。本节讨论解决这一问题的两种不同方案。

3.4.1 查找合并删除

查找合并删除：查找到删除节点P，将P节点删除，然后将左节点L、右节点R进行合并，最后将P父节点（如果有的话）指向L节点。

1）需要删除的节点，有左右孩子节点，下图中删除节点是点P，灰色节点表示该节点可以有可以没有。P节点可以有父节点，可以没有，如果有父节点，可以是父节点的左节点也可以是右节点，对结果没有影响。

2）P节点删除之后剩下：P节点父节点（如果有的话）、左节点L、右节点R。查找合并删除：查找到P节，将P节点删除，然后将P节点父节点（如果有的话）、左节点L、右节点R进行合并，准确来说是将左节点L、右节点R进行合并。

3）找到P节点右节点中最大节点，并将R节点接在最大节点右节点上，P父节点（如果有的话）指向L节点。

P节点的右节点中最大节点查找方法，一直查找L节点的右节点，直到最后一个没有右节点的节点D即为P节点中最大的节点，D节点的右节点指向R节点，合并完成，例如下图：

3.4.2 查找复制删除

查找复制删除：查找一个可以替换P节点位置的节点，将该节点元素复制到P节点中，并将该节点删除。能替换P节点位置的节点有两个，一个是P节点左节点中元素最大的节点，另一个是P节点右节点中元素最小的节点，这里用到的是P节点左节点中元素最大的节点。

1）需要删除的节点，有左右孩子节点，下图中删除节点是点P，灰色节点表示该节点可以有可以没有。P节点可以有父节点，可以没有，如果有父节点，可以是父节点的左节点也可以是右节点，对结果没有影响。

2）查找P节点左节点中最大的节点D

3) 将D节点元素复制到P节点中，D节点的父节点Pre指向D节点左节点，删除D节点。需要说明一下，如果Pre和P是同一个节点，则Pre左节点指向T节点，如果Pre和P不是同一个节点，则Pre右节点指向T节点。

 

四、二叉搜索树接口C++实现(代码说明)

4.1 基本定义

为了方便使用对栈和队列一些接口进行了重写。

template<class T>
class Stack: public stack<T> 
{
public:
    T pop() 
    {
        T tmp = stack<T>::top();
        stack<T>::pop();
        return tmp;
    }
};

template<class T>
class Queue: public queue<T> 
{
public:
    T dequeue() 
    {
        T tmp = queue<T>::front();
        queue<T>::pop();
        return tmp;
    }

    void enqueue(const T& m_el) 
    {
        queue<T>::push(m_el);
    }
};

template<class T>
class BSTNode 
{
public:
    BSTNode()
    {
        m_el = 0;
        m_left = nullptr;
        m_right = nullptr;
    }

    BSTNode(const T& e, BSTNode<T>* l = nullptr, BSTNode<T> * r = nullptr)
    {
        m_el = e; 
        m_left = l; 
        m_right = r;
    }

    T m_el;
    BSTNode<T>* m_left;
    BSTNode<T>* m_right;
};

 

4.2 搜索（查找）

递归实现和非递归实现，很容易理解直接看代码即可。

// 搜索，递归实现
template<class T>
T* BST<T>::recursiveSearch(BSTNode<T>* p, const T& m_el) const 
{
    if (p != 0)
    {
        if (m_el == p->m_el)
            return &p->m_el;
        else if (m_el < p->m_el)
            return recursiveSearch(p->m_left, m_el);
        else 
            return recursiveSearch(p->m_right, m_el);
    }
    else
        return 0;
}

// 搜索，非递归实现
template<class T>
T* BST<T>::search(BSTNode<T>* p, const T& m_el) const 
{
    while (p != 0)
    {
        if (m_el == p->m_el)
            return &p->m_el;
        else if (m_el < p->m_el)
            p = p->m_left;
        else 
            p = p->m_right;
    }

    return 0;
}

 

4.3 深度优先遍历

4.3.1 递归实现：前序遍历、中序遍历、后序遍历

递归实现的，前序遍历、中序遍历、后序遍历直接看代码即可。

// 前序遍历，递归实现
template<class T>
void BST<T>::preorder(BSTNode<T>* p)
{
	if (p != 0)
	{
        visit(p);
        preorder(p->m_left);
        preorder(p->m_right);
	}
}

// 中序遍历，递归实现
template<class T>
void BST<T>::inorder(BSTNode<T>* p) 
{
    if (p != 0) 
    {
        inorder(p->m_left);
        visit(p);
        inorder(p->m_right);
    }
}

// 后序遍历，递归实现
template<class T>
void BST<T>::postorder(BSTNode<T>* p) 
{
    if (p != 0) 
    {
        postorder(p->m_left);
        postorder(p->m_right);
        visit(p);
    }
}

4.3.2 非递归实现：前序遍历、中序遍历、后序遍历

// 前序遍历，非递归栈实现
template<class T>
void BST<T>::iterativePreorder() 
{
    Stack<BSTNode<T>*> travStack;
    BSTNode<T>* p = root;
    if (p != 0) 
    {
        travStack.push(p);
        while (!travStack.empty())
        {
            p = travStack.pop();
            visit(p);
            if (p->m_right != 0)
                travStack.push(p->m_right);

            if (p->m_left != 0)            
                travStack.push(p->m_left); 
        }
    }
}

// 中序遍历，非递归栈实现
template<class T>
void BST<T>::iterativeInorder() 
{
    Stack<BSTNode<T>*> travStack;
    BSTNode<T>* p = root;
    while (p != nullptr) 
    {
        while (p != nullptr)
        {                 
            if (p->m_right)                
                travStack.push(p->m_right); 

            travStack.push(p);
            p = p->m_left;
        }

        p = travStack.pop();             
        while (!travStack.empty() && p->m_right == nullptr)
        { 
            visit(p);                                
            p = travStack.pop();
        }

        visit(p);                       
        if (!travStack.empty())          
            p = travStack.pop();
        else 
            p = nullptr;
    }
}

// 后序遍历，非递归栈实现
template<class T>
void BST<T>::iterativePostorder() 
{
    Stack<BSTNode<T>*> travStack;
    BSTNode<T>* p = root, * q = root;
    while (p != nullptr) 
    {
        for (; p->m_left != nullptr; p = p->m_left)
            travStack.push(p);

        while (p->m_right == nullptr || p->m_right == q)
        {
            visit(p);
            q = p;
            if (travStack.empty())
                return;

            p = travStack.pop();
        }
        travStack.push(p);
        p = p->m_right;
    }
}

4.3.3 Morris遍历：前序遍历、中序遍历、后序遍历

// 前序遍历，非递归Morris遍历算法实现
template<class T>
void BST<T>::MorrisPreorder() 
{
    BSTNode<T>* p = root, * tmp;
    while (p != nullptr) 
    {
        if (p->m_left == nullptr)
        {
            visit(p);
            p = p->m_right;
        }
        else 
        {
            tmp = p->m_left;
            while (tmp->m_right != nullptr && tmp->m_right != p)
                tmp = tmp->m_right;   

            if (tmp->m_right == nullptr)
            {  
                visit(p);         
                tmp->m_right = p;    
                p = p->m_left;        
            }
            else 
            {                   
                tmp->m_right = nullptr;    
                p = p->m_right;       
            }                        
        }
    }
}

// 中序遍历，非递归Morris遍历算法实现
template<class T>
void BST<T>::MorrisInorder() 
{
    BSTNode<T>* p = root, * tmp;
    while (p != 0)
    {
        if (p->m_left == 0) 
        {
            visit(p);
            p = p->m_right;
        }
        else 
        {
            tmp = p->m_left;
            while (tmp->m_right != 0 &&
                tmp->m_right != p)  
                tmp = tmp->m_right;   
            if (tmp->m_right == 0) 
            {   
                tmp->m_right = p;    
                p = p->m_left;       
            }
            else 
            {                   
                visit(p);      
                tmp->m_right = 0;    
                p = p->m_right;      
            }                      
        }
    }
}

// 后序遍历，非递归Morris遍历算法实现
template<class T>
void BST<T>::MorrisPostorder() 
{
    BSTNode<T>* p = new BSTNode<T>(), * tmp, * q, * r, * s;
    p->m_left = root;
    while (p != 0)
    {
        if (p->m_left == 0)
            p = p->m_right;
        else
        {
            tmp = p->m_left;
            while (tmp->m_right != 0 && tmp->m_right != p)  
                tmp = tmp->m_right;   

            if (tmp->m_right == 0) 
            {   
                tmp->m_right = p;     
                p = p->m_left;        
            }
            else
            {             
                for (q = p->m_left, r = q->m_right, s = r->m_right;
                    r != p; q = r, r = s, s = s->m_right)
                    r->m_right = q;

                for (s = q->m_right; q != p->m_left;
                    q->m_right = r, r = q, q = s, s = s->m_right)
                    visit(q);

                visit(p->m_left);    
                tmp->m_right = 0;     
                p = p->m_right;      
            }                   
        }
    }
}

 

4.4 广度优先遍历

// 广度优先遍历：从上到下，从左到右
template<class T>
void BST<T>::breadthFirst() 
{
    Queue<BSTNode<T>*> queue;
    BSTNode<T>* p = root;
    if (p != 0) 
    {
        queue.enqueue(p);
        while (!queue.empty()) 
        {
            p = queue.dequeue();
            visit(p);
            if (p->m_left != 0)
                queue.enqueue(p->m_left);
            if (p->m_right != 0)
                queue.enqueue(p->m_right);
        }
    }
}

 

4.5 插入

非递归实现和递归实现

// 插入插入一个元素，非递归实现
template<class T>
bool BST<T>::insert(const T& m_el) 
{
    BSTNode<T>* p = root, * prev = 0;
    while (p != 0) 
    {  
        prev = p;
        if (m_el < p->m_el)
            p = p->m_left;
        else if (m_el > p->m_el)
            p = p->m_right;
        else
        {
            cout << "BST<T>::insert 插入相同的数据，插入失败" << endl;
            return false;
        }
    }

    if (root == 0)    
        root = new BSTNode<T>(m_el);
    else if (m_el < prev->m_el)
        prev->m_left = new BSTNode<T>(m_el);
    else 
        prev->m_right = new BSTNode<T>(m_el);

	return true;
}

// 插入插入一个元素，递归实现
template<class T>
bool BST<T>::recursiveInsert(BSTNode<T>*& p, const T& m_el) 
{
    if (p == 0)
        p = new BSTNode<T>(m_el);
    else if (m_el < p->m_el)
        recursiveInsert(p->m_left, m_el);
    else if (m_el > p->m_el)
        recursiveInsert(p->m_right, m_el);
    else
    {
        cout << "BST<T>::recursiveInsert 插入相同的数据，插入失败" << endl;
        return false;
    }
    
    return true; 
}

 

4.6 删除

查找复制删除和查找归并删除

// 查找复制删除
template<class T>
void BST<T>::findAndDeleteByCopying(const T& m_el) 
{
    BSTNode<T>* p = root, * prev = 0;
    while (p != 0 && p->m_el != m_el) 
    {
        prev = p;
        if (m_el < p->m_el)
            p = p->m_left;
        else 
            p = p->m_right;
    }

    if (p != 0 && p->m_el == m_el)
    {
        if (p == root)
            deleteByCopying(root);
        else if (prev->m_left == p)
            deleteByCopying(prev->m_left);
        else
            deleteByCopying(prev->m_right);
	}
    else if (root != 0)
        cout << "m_el " << m_el << " is not in the tree\n";
    else 
        cout << "the tree is empty\n";
}

// 查找复制删除
template<class T>
void BST<T>::deleteByCopying(BSTNode<T>*& node) 
{
    if (node == nullptr)
        return;
	
    BSTNode<T>* previous, * tmp = node;
    if (node->m_right == nullptr)                  // node 没有右节点
        node = node->m_left;
    else if (node->m_left == nullptr)              // node 没有左节点
        node = node->m_right;
    else 
    {
        tmp = node->m_left;							// node 有左、右节点
        previous = node;                   
        while (tmp->m_right != nullptr)
        {         
            previous = tmp;
            tmp = tmp->m_right;
        }

        node->m_el = tmp->m_el;                
        if (previous == node)
            previous->m_left = tmp->m_left;
        else 
            previous->m_right = tmp->m_left;   
    }

    delete tmp;                            
}

// 查找合并删除
template<class T>
void BST<T>::findAndDeleteByMerging(const T& m_el) 
{
    BSTNode<T>* p = root, * prev = 0;
    while (p != 0 && p->m_el != m_el)
    {
        prev = p;
        if (m_el < p->m_el)
            p = p->m_left;
        else 
            p = p->m_right;
    }

	if (p != 0 && p->m_el == m_el)
	{
        if (p == root)
            deleteByMerging(root);
        else if (prev->m_left == p)
            deleteByMerging(prev->m_left);
        else
            deleteByMerging(prev->m_right);
	}
    else if (root != 0)
        cout << "m_el " << m_el << " is not in the tree\n";
    else cout << "the tree is empty\n";
}

// 查找合并删除
template<class T>
void BST<T>::deleteByMerging(BSTNode<T>*& node) 
{
    if (node == nullptr)
        return;

    BSTNode<T>* tmp = node;
    if (node->m_right == nullptr)           // node 没有右节点
        node = node->m_left;     
    else if (node->m_left == nullptr)       // node 没有左节点
        node = node->m_right;    
    else 
    {                      
        tmp = node->m_left;      
        while (tmp->m_right != nullptr)
            tmp = tmp->m_right;

        tmp->m_right = node->m_right;           															
        tmp = node;							
        node = node->m_left;					
    }

    delete tmp;								
}

 

五、完整代码

// 通用二叉查找树的实现
#pragma once
#include <queue>
#include <stack>
#include <iostream>
using namespace std;

template<class T>
class Stack: public stack<T> 
{
public:
    T pop() 
    {
        T tmp = stack<T>::top();
        stack<T>::pop();
        return tmp;
    }
};

template<class T>
class Queue: public queue<T> 
{
public:
    T dequeue() 
    {
        T tmp = queue<T>::front();
        queue<T>::pop();
        return tmp;
    }

    void enqueue(const T& m_el) 
    {
        queue<T>::push(m_el);
    }
};

template<class T>
class BSTNode 
{
public:
	BSTNode()
	{
        m_el = 0;
        m_left = nullptr;
        m_right = nullptr;
	}

    BSTNode(const T& e, BSTNode<T>* l = nullptr, BSTNode<T> * r = nullptr)
    {
        m_el = e; 
        m_left = l; 
        m_right = r;
    }

	T m_el;
	BSTNode<T>* m_left;
	BSTNode<T>* m_right;
};

template<class T>
class BST 
{
public:
    BST()  { root = 0; }
    ~BST() { clear();  }

    void clear() 
    {
        clear(root);
        root = 0;
    }

	// 搜索，递归实现
	T* recursiveSearch(const T& m_el) const { return recursiveSearch(root, m_el); }
    // 搜索，非递归实现
    T* search(const T& m_el) const { return search(root, m_el); }

    // 前序遍历，递归实现
    void preorder()  { preorder(root); }
    // 中序遍历，递归实现
    void inorder()  { inorder(root); }
    // 后续遍历，递归实现
    void postorder()  { postorder(root); }
    // 前序遍历，非递归栈实现
    void iterativePreorder();
    // 中序遍历，非递归栈实现
    void iterativeInorder();
    // 后序遍历，非递归栈实现
    void iterativePostorder();
    // 前序遍历，非递归Morris遍历算法实现
    void MorrisPreorder();
    // 中序遍历，非递归Morris遍历算法实现
    void MorrisInorder();
    // 后序遍历，非递归Morris遍历算法实现
    void MorrisPostorder();

    // 广度优先遍历：从上到下，从左到右
    void breadthFirst();

    // 插入插入一个元素，非递归实现
    bool insert(const T&);
    // 插入插入一个元素，递归实现
    bool recursiveInsert(const T& m_el) { recursiveInsert(root, m_el); }

    // 查找合并删除
    void findAndDeleteByMerging(const T&);
    // 查找复制删除
    void findAndDeleteByCopying(const T&);

protected:
    BSTNode<T>* root;
    void clear(BSTNode<T>*);
    // 插入插入一个元素，递归实现
    bool recursiveInsert(BSTNode<T>*&, const T&);
    // 搜索（查找），非递归实现
    T* search(BSTNode<T>*, const T&) const;
    // 搜索（查找），递归实现
    T* recursiveSearch(BSTNode<T>*, const T&) const;
    // 前序遍历，递归实现
    void preorder(BSTNode<T>*);
    // 中序遍历，递归实现
    void inorder(BSTNode<T>*);
    // 后序遍历，递归实现
    void postorder(BSTNode<T>*);
    // 复制删除
    void deleteByCopying(BSTNode<T>*&);
    // 合并删除
    void deleteByMerging(BSTNode<T>*&);
    // 访问节点
    virtual void visit(BSTNode<T>* p) { cout << p->m_el << ' '; }
};

template<class T>
void BST<T>::clear(BSTNode<T>* p) 
{
    if (p != 0) 
    {
        clear(p->m_left);
        clear(p->m_right);
        delete p;
    }
}

// 搜索（查找），递归实现
template<class T>
T* BST<T>::recursiveSearch(BSTNode<T>* p, const T& m_el) const 
{
    if (p != 0)
    {
        if (m_el == p->m_el)
            return &p->m_el;
        else if (m_el < p->m_el)
            return recursiveSearch(p->m_left, m_el);
        else 
            return recursiveSearch(p->m_right, m_el);
    }
    else
        return 0;
}

// 搜索（查找），非递归实现
template<class T>
T* BST<T>::search(BSTNode<T>* p, const T& m_el) const 
{
    while (p != 0)
    {
        if (m_el == p->m_el)
            return &p->m_el;
        else if (m_el < p->m_el)
            p = p->m_left;
        else 
            p = p->m_right;
    }

    return 0;
}

// 前序遍历，递归实现
template<class T>
void BST<T>::preorder(BSTNode<T>* p)
{
	if (p != 0)
	{
        visit(p);
        preorder(p->m_left);
        preorder(p->m_right);
	}
}

// 中序遍历，递归实现
template<class T>
void BST<T>::inorder(BSTNode<T>* p) 
{
    if (p != 0) 
    {
        inorder(p->m_left);
        visit(p);
        inorder(p->m_right);
    }
}

// 后序遍历，递归实现
template<class T>
void BST<T>::postorder(BSTNode<T>* p) 
{
    if (p != 0) 
    {
        postorder(p->m_left);
        postorder(p->m_right);
        visit(p);
    }
}

// 前序遍历，非递归栈实现
template<class T>
void BST<T>::iterativePreorder() 
{
    Stack<BSTNode<T>*> travStack;
    BSTNode<T>* p = root;
    if (p != 0) 
    {
        travStack.push(p);
        while (!travStack.empty())
        {
            p = travStack.pop();
            visit(p);
            if (p->m_right != 0)
                travStack.push(p->m_right);

            if (p->m_left != 0)            
                travStack.push(p->m_left); 
        }
    }
}

// 中序遍历，非递归栈实现
template<class T>
void BST<T>::iterativeInorder() 
{
    Stack<BSTNode<T>*> travStack;
    BSTNode<T>* p = root;
    while (p != nullptr) 
    {
        while (p != nullptr)
        {                 
            if (p->m_right)                
                travStack.push(p->m_right); 

            travStack.push(p);
            p = p->m_left;
        }

        p = travStack.pop();             
        while (!travStack.empty() && p->m_right == nullptr)
        { 
            visit(p);                                
            p = travStack.pop();
        }

        visit(p);                       
        if (!travStack.empty())          
            p = travStack.pop();
        else 
            p = nullptr;
    }
}

// 后序遍历，非递归栈实现
template<class T>
void BST<T>::iterativePostorder() 
{
    Stack<BSTNode<T>*> travStack;
    BSTNode<T>* p = root, * q = root;
    while (p != nullptr) 
    {
        for (; p->m_left != nullptr; p = p->m_left)
            travStack.push(p);

        while (p->m_right == nullptr || p->m_right == q)
        {
            visit(p);
            q = p;
            if (travStack.empty())
                return;

            p = travStack.pop();
        }
        travStack.push(p);
        p = p->m_right;
    }
}

// 前序遍历，非递归Morris遍历算法实现
template<class T>
void BST<T>::MorrisPreorder() 
{
    BSTNode<T>* p = root, * tmp;
    while (p != nullptr) 
    {
        if (p->m_left == nullptr)
        {
            visit(p);
            p = p->m_right;
        }
        else 
        {
            tmp = p->m_left;
            while (tmp->m_right != nullptr && tmp->m_right != p)
                tmp = tmp->m_right;   

            if (tmp->m_right == nullptr)
            {  
                visit(p);         
                tmp->m_right = p;    
                p = p->m_left;        
            }
            else 
            {                   
                tmp->m_right = nullptr;    
                p = p->m_right;       
            }                        
        }
    }
}

// 中序遍历，非递归Morris遍历算法实现
template<class T>
void BST<T>::MorrisInorder() 
{
    BSTNode<T>* p = root, * tmp;
    while (p != 0)
    {
        if (p->m_left == 0) 
        {
            visit(p);
            p = p->m_right;
        }
        else 
        {
            tmp = p->m_left;
            while (tmp->m_right != 0 && tmp->m_right != p)  
                tmp = tmp->m_right;   
                
            if (tmp->m_right == 0) 
            {   
                tmp->m_right = p;    
                p = p->m_left;       
            }
            else 
            {                   
                visit(p);      
                tmp->m_right = 0;    
                p = p->m_right;      
            }                      
        }
    }
}

// 后序遍历，非递归Morris遍历算法实现
template<class T>
void BST<T>::MorrisPostorder() 
{
    BSTNode<T>* p = new BSTNode<T>(), * tmp, * q, * r, * s;
    p->m_left = root;
    while (p != 0)
    {
        if (p->m_left == 0)
            p = p->m_right;
        else
        {
            tmp = p->m_left;
            while (tmp->m_right != 0 && tmp->m_right != p)  
                tmp = tmp->m_right;   

            if (tmp->m_right == 0) 
            {   
                tmp->m_right = p;     
                p = p->m_left;        
            }
            else
            {             
                for (q = p->m_left, r = q->m_right, s = r->m_right;
                    r != p; q = r, r = s, s = s->m_right)
                    r->m_right = q;

                for (s = q->m_right; q != p->m_left;
                    q->m_right = r, r = q, q = s, s = s->m_right)
                    visit(q);

                visit(p->m_left);    
                tmp->m_right = 0;     
                p = p->m_right;      
            }                   
        }
    }
}

// 广度优先遍历：从上到下，从左到右
template<class T>
void BST<T>::breadthFirst() 
{
    Queue<BSTNode<T>*> queue;
    BSTNode<T>* p = root;
    if (p != 0) 
    {
        queue.enqueue(p);
        while (!queue.empty()) 
        {
            p = queue.dequeue();
            visit(p);
            if (p->m_left != 0)
                queue.enqueue(p->m_left);
            if (p->m_right != 0)
                queue.enqueue(p->m_right);
        }
    }
}

// 插入插入一个元素，非递归实现
template<class T>
bool BST<T>::insert(const T& m_el) 
{
    BSTNode<T>* p = root, * prev = 0;
    while (p != 0) 
    {  
        prev = p;
        if (m_el < p->m_el)
            p = p->m_left;
        else if (m_el > p->m_el)
            p = p->m_right;
        else
        {
            cout << "BST<T>::insert 插入相同的数据，插入失败" << endl;
            return false;
        }
    }

    if (root == 0)    
        root = new BSTNode<T>(m_el);
    else if (m_el < prev->m_el)
        prev->m_left = new BSTNode<T>(m_el);
    else 
        prev->m_right = new BSTNode<T>(m_el);

	return true;
}

// 插入插入一个元素，递归实现
template<class T>
bool BST<T>::recursiveInsert(BSTNode<T>*& p, const T& m_el) 
{
    if (p == 0)
        p = new BSTNode<T>(m_el);
    else if (m_el < p->m_el)
        recursiveInsert(p->m_left, m_el);
    else if (m_el > p->m_el)
        recursiveInsert(p->m_right, m_el);
	else
    {
        cout << "BST<T>::recursiveInsert 插入相同的数据，插入失败" << endl;
        return false;
    }
    
	return true; 
}


// 查找合并删除
template<class T>
void BST<T>::findAndDeleteByMerging(const T& m_el)
{
    BSTNode<T>* p = root, * prev = 0;
    while (p != 0 && p->m_el != m_el)
    {
        prev = p;
        if (m_el < p->m_el)
            p = p->m_left;
        else
            p = p->m_right;
    }

    if (p != 0 && p->m_el == m_el)
    {
        if (p == root)
            deleteByMerging(root);
        else if (prev->m_left == p)
            deleteByMerging(prev->m_left);
        else
            deleteByMerging(prev->m_right);
    }
    else if (root != 0)
        cout << "m_el " << m_el << " is not in the tree\n";
    else 
        cout << "the tree is empty\n";
}

// 查找合并删除
template<class T>
void BST<T>::deleteByMerging(BSTNode<T>*& node)
{
    if (node == nullptr)
        return;

    BSTNode<T>* tmp = node;
    if (node->m_right == nullptr)           // node 没有右节点
        node = node->m_left;
    else if (node->m_left == nullptr)       // node 没有左节点
        node = node->m_right;
    else
    {
        tmp = node->m_left;
        while (tmp->m_right != nullptr)
            tmp = tmp->m_right;

        tmp->m_right = node->m_right;
        tmp = node;
        node = node->m_left;
    }

    delete tmp;
}

// 查找复制删除
template<class T>
void BST<T>::findAndDeleteByCopying(const T& m_el) 
{
    BSTNode<T>* p = root, * prev = 0;
    while (p != 0 && p->m_el != m_el) 
    {
        prev = p;
        if (m_el < p->m_el)
            p = p->m_left;
        else 
            p = p->m_right;
    }

    if (p != 0 && p->m_el == m_el)
    {
        if (p == root)
            deleteByCopying(root);
        else if (prev->m_left == p)
            deleteByCopying(prev->m_left);
        else
            deleteByCopying(prev->m_right);
	}
    else if (root != 0)
        cout << "m_el " << m_el << " is not in the tree\n";
    else 
        cout << "the tree is empty\n";
}

// 查找复制删除
template<class T>
void BST<T>::deleteByCopying(BSTNode<T>*& node) 
{
    if (node == nullptr)
        return;
	
    BSTNode<T>* previous, * tmp = node;
    if (node->m_right == nullptr)                  // node 没有右节点
        node = node->m_left;
    else if (node->m_left == nullptr)              // node 没有左节点
        node = node->m_right;
    else 
    {
        tmp = node->m_left;							// node 有左、右节点
        previous = node;                   
        while (tmp->m_right != nullptr)
        {         
            previous = tmp;
            tmp = tmp->m_right;
        }

        node->m_el = tmp->m_el;                
        if (previous == node)
            previous->m_left = tmp->m_left;
        else 
            previous->m_right = tmp->m_left;   
    }

    delete tmp;                            
}

 

 

 

 

聂炳玉
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构二叉树实验——构造二叉搜索树
06-05
第一行是搜索树的后面输入值的个数 第二行是依次插入节点的key(节点的key是整数) 输入的key值可能重复，如果已经形成的搜索树中存在该key，则不再插入
二叉搜索树简单介绍
jx_zls的博客
03-31 211
目录二叉搜索树1. 概述2. 查询二叉搜索树1. 查找1. 查找伪代码2. 最大关键字元素和最小关键字元素1. 最小关键字元素2. 最小关键字元素伪代码3. 最大关键字元素伪代码4. 后继和前驱5. 后继伪代码2. 插入和删除1. 插入1. 插入伪代码2. 删除1. 移动伪代码2. 删除伪代码 二叉搜索树 1. 概述 一棵二叉搜索树是以一棵二叉树组织的，其中每个结点就是一个对象，每个节点包含属性l...
二叉查找树
qq_45832461的博客
08-27 8505
二叉查找树 简介 二叉查找树(Binary Search Tree，BST)，又叫做二叉排序树、二叉搜索树，是一种对查找和排序都有用的特殊二叉树。 二叉查找树或是空树，或是满足如下三个性质的二叉树： 若其左子树非空，则左子树上所有节点的值都小于根节点的值 若其右子树非空，则右子树上所有节点的值都大于根节点的值 其左右子树都是一棵二叉查找树 二叉查找树的特性：左子树<根<右子树，即二叉查找树的中序遍历是一个递增序列。 如下图所示，其中序遍历为{5,18,29,25,32,25,69} 我们
查找(折半,二叉排序树,二叉平衡树,B树,散列表)
09-27
代码和讲解 字符串,模式匹配,BF模式匹配,算法 查找(顺序,折半,插值,斐波那契,分块,二叉排序树,二叉平衡树,B树,散列表)代码和讲解,内容详细全面,通俗易懂,通过测试,代码可以直接使用,方便大家学习.
考研常考的二叉树相关算法总结（详细全面，PDF版）
11-16
并含递归和非递归方式等的算法、求二叉树的深度、删除二叉树中以某个结点为根结点的子树、判别两棵树是否相等和是否是完全二叉树、二叉排序树的构造、查找和插入等等算法、孩子兄弟表示法的构造等算法。（含真题） ...
数据结构基础(C语言版)(第2版).part2/2
01-22
此外，本书还介绍了各种高级或特殊数据结构，如优先级队列、高效二叉查找树、多路查找树等。本书对大多数算法都给出了计算时间在最优、最差情形下的复杂度分析。 　本书不仅可以作为计算机及相关专业本科生“数据...
全面的算法代码库
04-08
普通的二叉搜索树 Binary-Search-Tree 广度优先搜索 Breadth-First-Search 冒泡排序 Bubble-Sort 桶排序 Bucket-Sort 组合数的递推求解 Combination(Recursion) 枚举组合 Combination 基本的复数类 Complex-...
数据结构c语言版第2版课后习题答案pdf高清
07-02
此外，《数据结构基础(C语言版)(第2版)》还介绍了各种高级或特殊数据结构，如优先级队列、高效二叉查找树、多路查找树等。《数据结构基础(C语言版)(第2版)》对大多数算法都给出了计算时间在最优、最差情形下的复杂度...
二叉查找树与平衡二叉树
热门推荐
金发只是水一下的博客
08-29 8万+
二叉查找树 　　二叉查找树，也称二叉搜索树，或二叉排序树。其定义也比较简单，要么是一颗空树，要么就是具有如下性质的二叉树： （1）若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2） 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3） 任意节点的左、右子树也分别为二叉查找树； （4） 没有键值相等的节点。 　　如上图所示，是不同形态...
二叉搜索树详解（附代码）
张凯
08-10 1万+
今天讲一下二叉搜索树 文章目录1. 定义2. BST数据结构的实现2.1. 定义树结点 1. 定义 这里我们引用百度百科的解释： 二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数.
数据结构之二叉搜索树详解
小赵小赵福星高照的博客
03-05 661
二叉搜索树 文章目录二叉搜索树二叉搜索树概念二叉搜索树的操作二叉搜索树的节点结构二叉搜索树的结构二叉搜索树的查找二叉搜索树的插入二叉搜索树的遍历二叉搜索树的删除二叉搜索树插入的递归写法二叉搜索树查找的递归写法二叉搜索树删除的递归写法二叉搜索树增删查改操作代码二叉搜索树的应用Key搜索场景KV搜索场景(key-value)二叉搜索树概念二叉搜索树的操作二叉搜索树的节点结构二叉搜索树的结构二叉搜索树的查找二叉搜索树的插入二叉搜索树的遍历二叉搜索树的删除二叉搜索树插入的递归写法二叉搜索树查找的递归写法二叉搜索树删
二叉搜索树和二叉查找树
最新发布
07-28
回答: 二叉搜索树和二叉查找树是同一个概念，都是指一种特殊的二叉树结构，其中每个节点的值都大于其左子树中的所有节点的值，且小于其右子树中的所有节点的值。二叉搜索树的创建可以从空树开始，按照输入关键字的顺序依次进行插入操作，最终得到一棵二叉搜索树。\[1\]由于二叉搜索树的中序遍历有序性，即得到的递增的序列，因此可以利用二分查找的思想进行查找操作，每次都可以缩小查找范围，查询效率较高。\[2\]在删除操作中，如果被删除节点的左子树为空，则令其右子树代替其位置；如果被删除节点的右子树为空，则令其左子树代替其位置；如果被删除节点的左右子树都不为空，则可以选择其直接前驱或者直接后继代替它，再删除其直接前驱或者直接后继即可。\[3\] #### 引用[.reference_title] - *1* *2* *3* [【数据结构】二叉查找树（BST）](https://blog.csdn.net/m0_46628950/article/details/126768144)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值