二叉树的基本操作

最新推荐文章于 2021-07-12 10:07:40 发布
最新推荐文章于 2021-07-12 10:07:40 发布
阅读量589 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉树 数据结构 基本操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lizhidefengzi/article/details/70945178
版权

百度百科：二叉树
刷题是学习数据结构，整理自己的思路最快的方法。所以推荐大家多思考，人人都会敲代码，但是思路不一定每个人都会有。

题目

主要问题

1.求一个结点的父节点
2.求结点的左兄弟结点或右兄弟结点
3.求一颗二叉树的高度
4.求结点i的深度
5.根据一颗二叉树的前序和中序重建一棵二叉树

1.求一个结点的父结点

方法一：我们知道，二叉树的相关操作无非就是，几种遍历方式，然后进相应的操作即可，那么首先想到的就是递归遍历。
如果我当前结点的左孩子或者右孩子等于遍历查找返回的结点，那么那么我们就返回结点。

    Node* _Parent(Node* root ,Node * cTest)
    {
        if (root == NULL)
        {
            return NULL;
        }

        if (root->_pLeft == NULL&&root->_pRight == NULL)
        {
            return NULL;
        }

        if (root->_pLeft == cTest||root->_pRight==cTest)
        {
            return root;
        }
        Node* parent= _Parent(root->_pLeft, cTest);
        if (parent)
        {
            return  parent;
        }
        return _Parent(root->_pRight,cTest);
    }

方法二：跟父节点有关系的，我们还可以想到层序遍历，如果左右孩子不为空，就将其左右孩子结点入队。在入之前我们可以进行判断，如果相等，我们就将其父结点返回.

    Node* ParentNode(Node * node)
    {
        if (node == NULL || _pRoot == node)
        {
            return NULL;
        }

        int max = 50;
        int front, rear;
        Node* current, *child;
        int count = 0;
        if (node != NULL)
        {
            Node*  queue[max];
            front = rear = 0;
            queue[rear++] = node;
            count++;
            while (count != 0)
            {
                current = queue[front];
                if (current->_pLeft)
                {
                    child = current->_pLeft;
                    if (node == child)
                    {
                        return current;
                    }
                    else
                    {
                        //入队
                        queue[rear] = child;
                        rear = (rear + 1)%max;//循环队列实现方式
                        count++;
                    }
                }

                if (current->_pRight)
                {
                    child = current->_pRight;
                    if (child == node)
                    {
                        return current;
                    }
                    else
                    {
                        queue[rear] = child;
                        rear = (rear + 1) % max;
                        count++;

                    }

                }

                front = (front + 1) % max;//出队
                count--;

            }
        }
        return NULL;
    }
2.求结点的左兄弟结点或右兄弟结点

思路：找到父节点后（第一题），其兄弟结点很容易知道，不再累赘。

3.求一颗二叉树的高度

**两种实现方式：
思路1.递归法**
思路：先求其左子树的高度，再求其右子树的高度，取其较高者，就是该树的高度

    size_t _Height(Node* root)
    {
        //左右子树最深的个数加1就是当前树的深度
        if (root == NULL)
        {
            return 0;
        }

        size_t left = _Height(root->_pLeft);
        size_t right = _Height(root->_pRight);
        return left > right ? left + 1 : right + 1;
    }

思路二：遍历法
一直走到根节点，更新最大长度，循环结束后，即可得该树的高度。

template<typename DataType>
size_t BinaryTree<DataType>::getDepth(int numberofNodes)
{
    BinaryTreeNode<DataType>* nodeStack = new BinaryTreeNode<DataType>[numberofNodes];//设置存储二叉树结点的栈
    int depthStak[numberofNodes];//声明深度栈
    int currentDepth, maxDepth = 0;
    int top = -1;
    BinaryTreeNode<DataType>*node = root;

    if (node != NULL)
    {
        currentDepth = 1;//高度从0开始计数
        do
        {
            while (node != NULL)
            {
                nodeStack[++top] = node;//M模拟栈这样的使用top，当取的时候非常方便
                node = node->lChild;
                depthStack[top] = currentDepth;
                currentDepth++;
            }

            node = nodeStack[top];
            currentDepth = depthStack[top--];//出栈，并且取出上一步的高度
            if (node->lChild == NULL&&node->rChild == NULL)
            {
                if (currentDepth > maxDepth)
                {
                    maxDepth = currentDepth;
                }
            }
            node = node->rChild;
            currentDepth++;

        } while (!(node == NULL&&top == -1));
    }       
    return maxDepth;
}
4.求结点i的深度

思路：纵观这些题，我们可以知道无非就是就是遍历只是操作和返回的东西不一样，根据栈的性质进行前进或者回溯不断缩小问题规模。所以就会有两种方法：递归和非递归
这里为了更好的理解：后序遍历的非递归方式，这里我们用后序遍历来解决这个问题，注意我们的flagStack.就是来区分前中后序遍历的。

template<typename DataType>
int BinaryTree<DataType>::getDepthofNode(DataType i)
{
    int stackSize = 0;
    BinaryTreeNode<DataType>* nodeStack[stackSize];
    int flagStack[StackSize];//存储每个结点的状态
    int flag = 0;
    int top = -1;

    BinaryTreeNode<DataType>* node = root;

    do{
        while (node != NULL)
        {
            nodeStack[++top] = node;
            flagStack[top] = 0;
            node = node->_pLeft;
        }

        node = nodeStack[top];
        flag = flagStack[top--];

        if (flag = 0)
        {
            nodeStack[++top] = node;//将第一次访问的结点再次入栈
            flagStack[top] = 1;
            node = node->rChild;
        }
        else
        {
            if (node->_data == i)
            {
                return top + 2;
            }
            node = NULL;
        }
    } while (!(node==NULL&&top==-1))
}
5.根据一颗二叉树的前序和中序重建一棵二叉树

根据二叉树遍历的性质，我们可以知道前序的第一个结点是根结点，据此，我们就可以把中序遍历的结果分为两份，一份左半子树，一份右半子树。

void ReBuild(char*pPreOrder, char* pInorder, int nTreeLen, Node**pRoot)
{
    //检查边界
    if (pPreOrder == NULL || pInOrder == NULL)
    {
        return;
    }
    Node* temp = new Node;
    temp->data = *pPreOrder;

    if (pRoot == NULL)
    {
        *pRoot = temp;
    }

    if (nTreeLen == 1)
    {
        return;
    }
    char* pOrgInOrder = pInOrder;
    char* pLeftEnd = pInOrder;

    int nTempLen = 0;
    while (*pPreOrder != *pLeftEnd)
    {
        if (pPreOrder == NULL || pLeftEnd == NULL)
            return;
        nTempLen++;
        if (nTempLen > nTreeLen)break;
        pLeftEnd++;
    }

    int nLeftLen = (int)(pLeftEnd - pOrgInOrder);
    int nRightLen = nTreeLen - nLeftLen - 1;

    if (nLeftLen > 0)
    {
        ReBuild(pPreOrder + 1, pInOrder, nLeftLen, &((*pRoot)->left));
    }
    if(nRightLen > 0)
    {
        ReBuild(pPreOrder + nLeftLen + 1, pInOrder + nLeftLen + 1, nRightLen, &((*pRoot)->right));
    }
}

其余基本操作完整代码：

#include<iostream>
#include<queue>
#include<assert.h>
using namespace std;

//二叉树的构建、销毁、赋值，拷贝构造。、遍历、修改、查找、


template<typename T>
struct BinaryTreeNode
{
    BinaryTreeNode<T>(const T&data=T())
    : _data(data)
    , _pLeft(NULL)
    , _pRight(NULL)
    {}
    T _data;
    BinaryTreeNode<T>* _pLeft;
    BinaryTreeNode<T>*_pRight;
};

template<typename T>
class BinaryTree
{
    typedef BinaryTreeNode<T> Node;
public:
    BinaryTree()
        :_pRoot(NULL)
        , _invalid(T())
    {
    }
    BinaryTree(const T arr[], const size_t length,const T& invalid)
    {
        size_t index = 0;
        _pRoot = _CreateTree(_pRoot, arr, length, index,invalid);
    }
    //前序遍历
    void PreOrder()
    {
        _PreOrder(_pRoot);
    }
    void InOrder()
    {
        _InOrder(_pRoot);
    }
    void MidOrder()
    {
        _MidOrder(_pRoot);

    }
    void LevelOrder()
    {
    //层序遍历

        //利用队列实现因为需要先入的先访问，如果按照栈的特点来做，访问左孩子后，为了方便访问下一层，需要保存它的左右孩子，无法访问按层序访问右孩子，因为已经插上来了
        //所以我们使用队列，就可以满足这一点

        //只需要一个循环就能实现
        if (_pRoot != NULL)
        {
            queue<Node*>q;
            q.push(_pRoot);

            while (!q.empty())
            {
                Node*cur = q.front();
                q.pop();
                cout << cur->_data<<" ";
                if (cur->_pLeft)
                {
                    q.push(cur->_pLeft);
                }
                if (cur->_pRight)
                {
                    q.push(cur->_pRight);
                }
            }
        }
    }


    //拷贝构造函数
    BinaryTree(const BinaryTree<T>& Bt)
    {
        //根据指针拷贝对象
        _pRoot = _Copy(Bt._pRoot);
    }


    //赋值函数
    BinaryTree<T>* operator =(BinaryTree<T>Bt)
    {
        //基本框架一样    或者采用新赋值方法，交换两者的空间。然后函数结束，销毁临时对象
        if (_pRoot != &Bt._pRoot)
        {
            //拷贝
            BinaryTree<T> temp(Bt);

            Destory(_pRoot);
            //释放新空间

            _pRoot = temp._pRoot;

        }
        return *this;

    }

    //查找

    Node* Find(const T& t)
    {
        return _Find(_pRoot, t);

    }


    //找出该节点的父亲结点
    //思路：

    //求叶子节点的个数


    Node* Parent(Node* cTest)
    {
        return _Parent(_pRoot,cTest);
    }
    Node* _Parent(Node* root ,Node * cTest)
    {
        if (root == NULL)
        {
            return NULL;
        }

        if (root->_pLeft == NULL&&root->_pRight == NULL)
        {
            return NULL;
        }

        if (root->_pLeft == cTest||root->_pRight==cTest)
        {
            return root;
        }
        Node* parent= _Parent(root->_pLeft, cTest);
        if (parent)
        {
            return  parent;
        }
        return _Parent(root->_pRight,cTest);
    }


    //求一个节点的父亲结点—方法二
    //利用层序遍历（这一次我们自己实现一个队列）的思路如果结点等于其左子树或者右子树，将其返回
    Node* ParentNode(Node * node)
    {
        if (node == NULL || _pRoot == node)
        {
            return NULL;
        }

        int max = 50;
        int front, rear;
        Node* current, *child;
        int count = 0;
        if (node != NULL)
        {
            Node  queue[max];
            front = rear = 0;
            queue[rear++] = node;
            count++;
            while (count != 0)
            {
                current = queue[front];
                if (current->_pLeft)
                {
                    child = current->_pLeft;
                    if (node == child)
                    {
                        return current;
                    }
                    else
                    {
                        //入队
                        queue[rear] = child;
                        rear = (rear + 1)%max;//循环队列实现方式
                        count++;
                    }
                }

                if (current->_pRight)
                {
                    child = current->_pRight;
                    if (child == node)
                    {
                        return current;
                    }
                    else
                    {
                        queue[rear] = child;
                        rear = (rear + 1) % max;
                        count++;

                    }

                }

                front = (front + 1) % max;
                count--;

            }
        }
        return NULL;
    }


    //求数的高度
    size_t Height()
    {
        return _Height(_pRoot);
    }



    //节点个数

    size_t size()
    {
     size_t count = 0;
     _size(_pRoot,count);
     return count;
    }

    //叶子节点个数
    size_t leaf()
    {
        size_t count = 0;
        _leaf(_pRoot,count);
        return count;
    }


    ~BinaryTree()
    {
    //销毁函数
        DestoryTree(_pRoot);
        _pRoot = NULL;

    }


protected:
    //递归创建是一个二叉树
    //Node*_CreateTree(Node* pRoot, const T arr[], const size_t length, size_t & index,const T &invalid)
    //{
    //  if (pRoot == NULL)
    //  {
    //      if (index < length&&arr[index] != invalid)
    //      {
    //          pRoot = new Node(arr[index]);
    //      }
    //  }
    //  if (pRoot)
    //  {
    //      _CreateTree(pRoot->_pLeft, arr, length, ++index, invalid);
    //      _CreateTree(pRoot->_pRight, arr, length, ++index, invalid);
    //  }
    //  return pRoot;
    //}


    Node* _CreateTree(Node* &pRoot,const T arr[],const size_t length,size_t&index,const T&invalid)
    {
        Node* temp = NULL;
        if (index<length&&arr[index]!=invalid)//pRoot为空不能作为遍历结束条件
        {
            //先对根进行操作
            temp = new Node(arr[index]);
            pRoot = temp;

            _CreateTree(pRoot->_pLeft, arr, length, ++index, invalid);//在遍历左子树
            _CreateTree(pRoot->_pRight, arr, length, ++index, invalid);//在遍历右子树
        }
        return temp;

    }

    //四种遍历：前中后。层
    void _PreOrder(Node* pRoot)
    {

        if (pRoot)
        {
            cout << pRoot->_data << " ";
            _PreOrder(pRoot->_pLeft);
            _PreOrder(pRoot->_pRight);
        }
    }
    void _InOrder(Node* pRoot)
    {
        if (pRoot)
        {
            _InOrder(pRoot->_pLeft);
            _InOrder(pRoot->_pRight);
            cout << pRoot->_data << " ";
        }
    }
    void _MidOrder(Node* pRoot)
    {
        if (pRoot)
        {
            _PreOrder(pRoot->_pLeft);
            cout << pRoot->_data << " " << endl;
            _PreOrder(pRoot->_pRight);
        }       
    }

    //拷贝构造函数
    //Node* _Copy(Node* node)
    //{
    //  Node* cur = node;
    //  Node* root = NULL;
    //  if (cur)
    //  {
    //      root = new Node(cur->_data);
    //      root->_pLeft = _Copy(cur->_pLeft);
    //      root->_pRight = _Copy(cur->_pRight);
    //  }
    //  return root;
    //
    //}


    Node* _Copy(Node* node)
    {
        Node* root = NULL;
        if (node)
        {
            root = new Node(node->_data);
            root->_pLeft = _Copy(node->_pLeft);
            root->_pRight = _Copy(node->_pRight);

        }
        return root;
    }

    Node* _Find(Node* root, const T & t)
    {
        if (root)
        {
            if (root->_data == t)
            {
                return root;
            }

            Node* ret = _Find(root->_pLeft, t);      //此处不应该如此，因为一直递归到最深处，假如没有找到，肯定函数返回为NULL，整个函数结束
            if (ret)
            {
                return ret;
            }

            return _Find(root->_pRight, t);

        }
        return root;
    }

    size_t _Height(Node* root)
    {
        //左右子树最深的个数加1就是当前树的深度
        if (root == NULL)
        {
            return 0;
        }

        size_t left = _Height(root->_pLeft);
        size_t right = _Height(root->_pRight);
        return left > right ? left + 1 : right + 1;
    }

    void _size(Node* root,size_t & count)
    {
        if (root)
        {
            if (root->_pLeft == NULL&&root->_pRight == NULL)
            {
                return;
            }
            _size(root->_pLeft, ++count);
            _size(root->_pRight, ++count);
        }
    }

    size_t _leaf(Node* root,size_t &count)
    {
        if (root == NULL)
        {
            return 0;
        }

        if (root->_pLeft == NULL&&root->_pRight == NULL)
        {
            count++;
        }
        _leaf(root->_pLeft, count);
        _leaf(root->_pRight, count);
    }

    //销毁函数
    void DestoryTree(Node*pRoot)
    {
        if (pRoot)
        {
            DestoryTree(pRoot->_pLeft);
            DestoryTree(pRoot->_pRight);
            delete pRoot;
            pRoot = NULL;
        }

    }

private:
    Node* _pRoot;
    T _invalid;

};


void Test()
{
    int arr[] = { 1,2, 4, '#', '#', '#', 3, 5, '#', '#', 6 };

    BinaryTree<int> Bt(arr,sizeof(arr)/sizeof(arr[0]),'#');
    //Bt.MidOrder();
    //Bt.InOrder();
    //Bt.PreOrder();
    //Bt.LevelOrder();

    /*BinaryTree<int> Bt1(Bt);
    Bt1.PreOrder();
    cout << endl;
    BinaryTreeNode<int>* cur = Bt1.Find(6);
    cout << cur->_data << " ";*/


    BinaryTreeNode<int>*  cur = Bt.Find(6);
    BinaryTreeNode<int>*parent = Bt.Parent(cur);
    cout << parent->_data << endl;

    cout << "size::" << Bt.size() << " " << "Height::" << Bt.Height() << " Leaf::" << Bt.leaf() << endl;


}

int main()
{

    Test();

    return 0;
}
Steve_Abelieve
关注
专栏目录
二叉树的基本操作以及相关问题的求解—C++实现
Gary的面包屑小道
01-02 494
二叉树 二叉树是重要的数据结构，在学习中以及考试、面试中不可避免的考点，现在我就把有关二叉树的操作用C++总结 一下，可能有些同学使用的是C语言，但是无论C语言还是c++，对于二叉树的操作方法都是一样的，之后，我也会抽空给出C语言的实现。 本次实现是在vs2008的一个集成开发环境，为了增强代码的复用性，此次编写使用了模版，关于模版可以参考的我的另外一篇博客：http://blog.csdn.
二叉树基本操作及其常见面试题
zym1348010959的博客
05-07 378
前面的一些博客有谈到链表和顺序表这些数据结构，这些都属于一对一的线性结构，而在我们处理一对多的问题时，线性结构时常显得不够用，这个时候我们就引入了一种新的数据结构，树！ 大概长下面这样子： 一个结点拥有多少棵子树称结点的度为多少，而我们今天要聊的重点是树中的一个重要分支，二叉树。 二叉树是不存在任何度大于二的树，左右子树有序，不能存在颠倒，即使只有一棵子树，也要区分左子树还是右子树。 ...
【二叉树】47 二叉树：查找x
windyuan~
02-25 1610
问题描述 : 目的：使用C++模板设计并逐步完善二叉树的抽象数据类型（ADT）。 内容： （1）请参照链表的ADT模板，设计二叉树并逐步完善的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的链表ADT原型文件，自行设计二叉树的ADT。） 注意：二叉树ADT的基本操作的算法设计很多要用到递归的程序设计方法。 （2）基本操作8：在二叉树的二叉链表存储形式建立的基础上，.
计算机二级front和rear什么意思,关于计算机二级考试内容
weixin_28739079的博客
07-12 3017
为了让大家更好的备考计算机二级考试，练习往年真题很重要，下面由出国留学网小编为你准备了“计算机二级考试内容office真题”，仅供参考，持续关注本站将可以持续获取更多的内容资讯！计算机二级考试内容office真题【一】选择题1.下列叙述中错误的是()。A.对于各种特定的输入，算法的时间复杂度是固定不变的B.算法的时间复杂度与使用的计算机系统无关C.算法的时间复杂度与使用的程序设计语言无关D.算法的...
二叉树基本操作实验
CS@zeny的博客
11-20 1255
数据结构(实验报告)–二叉树 二叉树的基本操作 实验目的： 理解二叉树的定义 掌握二叉树的链式存储结构 掌握二叉树基本操作的递归算法 实验内容： 先序创建二叉树； 分别实现二叉树的先序、中序、后序递归遍历； 如果将空孩子显示为‘#’,实现二叉树的先序递归遍历 统计二叉树的结点数和叶结点数（写在同一个函数里）； 计算二叉树的深度； 交换二叉树的左右子树； 销毁二叉树。 实验代码 #include <stdio.h> #include <malloc.h&g
二叉树基本操作
04-30
1、根据输入的数据建立一个二叉树； 2、分别采用前序、中序、后序的遍历方式显示输出二叉树的遍历结果 3、采用非递归的编程方法，分别统计二叉树的节点个数、度为1、度为2和叶子节点的个数，以及数据值的最大值和...
实验四 二叉树基本操作的实现
12-18
在本实验中，我们将深入探讨数据结构中的一个重要概念——二叉树，并实现其基本操作。二叉树是一种非线性的数据结构，它由一个有限集合的节点构成，每个节点最多有两个子节点，通常称为左子节点和右子节点。这个实验...
二叉树基本操作的程序实现.zip_二叉树的基本操作
09-21
这篇文档“二叉树基本操作的程序实现”涵盖了二叉树的一些核心概念和基本操作，旨在帮助初学者理解并实现这些概念。 二叉树由节点构成，每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树的主要类型有...
二叉树-基于C语言实现的二叉树基本操作.zip
最新发布
04-26
本压缩包包含的是基于C语言实现的二叉树基本操作，是学习和理解二叉树概念以及其实现的一个宝贵资源。 在C语言中，实现二叉树通常涉及定义一个结构体来表示节点，这个结构体至少包含两个指针，分别指向左右子节点，...
二叉树基本操作_二叉树基本操作_
10-02
二叉树的基本操作主要包括创建、查找、插入和删除节点，这些操作对于理解和掌握二叉树至关重要。接下来，我们将详细讨论这些操作。 1. **创建二叉树** 创建一个二叉树首先需要定义二叉树节点的数据结构。在链表...
实现一个位图、100亿个整数找出只出现一次的整数、找出现次数不超多2次的数
Steve_Abelieve
08-05 3671
1.–实现一个位图。 位图特点： 节省空间 适合数据比较密集的情况 适合判断事件 是否 这样的问题 相关位运操作： & | ~ 代码实现：#include<iostream> #include<vector>using namespace std;// //1.【基础题】--实现一个位图。 //位图特点： 节省空间，适合数据密集的情况 class BitSet {
求一个无序数组的中位数
Steve_Abelieve
08-04 2905
求一个无序数组的中位数。如：{2,5,4,9,3,6,8,7,1}的中位数为5，{2,5,4,9,3,6,8,7,1,0}的中位数为4和5。 要求：不能使用排序，时间复杂度尽可低。实现思路：解法一：快排思想【背景知识】 1.快速排序可以实现将数据划分为 三部分 ： 左边小于基准值 基准值 右边大于基准值位置2.每次划分都可以将基准值的最终确定， 那这样的话，我们找中位数就很方便了。
【leetcode】链表的基本操作
Steve_Abelieve
04-29 2275
题目一： Reverse a singly linked list. 1->2->3->NULL NULL-<1-<2-<3 解法：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) :
迷宫出口以及迷宫最短路径的求解
Steve_Abelieve
04-20 1673
整理出来方便大家复习//完成迷宫 #pragma warning (disable:4996) #include<iostream> #include<vector> #include<stack> using namespace std; #include<assert.h> //创建迷宫->动态创建二维数组：1.int[][N] 2.int*->（二维数组是按照一维数组来存储的） //打印迷宫
稀疏矩阵的相关操作(存储、转置、快速转置、相加)
Steve_Abelieve
04-22 1258
题目要求：稀疏矩阵的压缩存储 template<class T> class SparseMatrix { template<class T> struct Trituple { Trituple(size_t row, size_t col, const T& data) : _row(row) , _col(
模拟实现atoi和itoa以及100G 的IP地址求出现次数最多的前K个IP
Steve_Abelieve
08-09 974
1.模拟实现C库的atoi和itoa。 2.给一个超过100G的log file, log中存着IP地址, 设计算法找到出现次数最多的100个IP地址？ 1.题考察面试者的思维方式：完整性和鲁棒性 先想好测试用例，沟通好错误处理，才能满意的做完。错误需要考虑的情况有： 1.当字符串为空时返回0，0字符串返回值也是0，但是两者的含义不同，我们应该做到区分，怎么区分？ 定义全局变量，设
简单布隆过滤器实现、布隆过滤器扩展
Steve_Abelieve
08-06 894
1.【基础题】–实现一个简单的布隆过滤器。 如果想要判断一个元素是不是在一个集合里，一般想到的是将所有元素保存起来，然后通过比较确定。链表，树等等数据结构都是这种思路. 但是随着集合中元素的增加，我们需要的存储空间越来越大，检索速度也越来越慢(O(n),O(logn))。不过世界上还有一种叫作散列表（又叫哈希表，Hash table）的数据结构。它可以通过一个Hash函数将一个元素映
二叉树基本操作的实现
10-25
下面是二叉树基本操作的实现方法： 1. 创建二叉树：通过前序遍历的数组构建二叉树，其中 '#' 表示空节点。具体实现方法可以参考引用中的 BinaryTreeCreate 函数。 2. 销毁二叉树：遍历二叉树，依次释放每个节点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值