算法 - Tree

最新推荐文章于 2023-03-25 06:15:00 发布
最新推荐文章于 2023-03-25 06:15:00 发布
阅读量431 收藏 1
点赞数
分类专栏： Algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liqingbing12/article/details/102730465
版权

 

树的相关算法

           1
         /   \
        2     3
      /   \    \
     9     10   4
      \    /   /  \
       12 11  5    6
      /  \  \     /  \
    13    14 15  7    8

1. 根据先序和中序构建二叉树

主要思路：先从先序序列中确定根节点，在从中序中确认根节点两侧的左右子树递归创建

    TreeNode* BuildTree(vector<int>& pre, vector<int>& in)
    {

        if (pre.size() == 0 || pre.size() != in.size()) return NULL;

        m_root = BuildTreeInternal(pre, 0, pre.size() - 1, in, 0, in.size() - 1);

        return m_root;
    }

    TreeNode* BuildTreeInternal(vector<int>& pre, int ps, int pe, vector<int>& in, int is, int ie) 
    {

        if ( ps > pe && is > ie ) return NULL;

        int data = pre[ps];
        int mid = 0;
        vector<int>::iterator it = find(in.begin(), in.end(), data);

        if (it != in.end()) mid = it - in.begin();
        int llen = mid - is; //说明要以当前root为根节点对需要建树的序列b左子树长
        int rlen = ie - mid; //说明要以当前root为根节点对需要建树的序列b右子树长

        TreeNode* tn = new TreeNode();
        tn->m_data = data;
        tn->m_left = BuildTreeInternal(pre, ps + 1, ps + llen, in, is, is + llen -1);
        tn->m_right = BuildTreeInternal(pre, pe - rlen + 1, pe, in, ie - rlen + 1, ie);

        return tn;
    }

2. 计算树的高度

主要思路：树的高度 = max(左子树高度， 右子树高度）+ 1

    int GetHeight(TreeNode* node) 
    {
        if(node == NULL) return 0;
        return (GetHeight(node->m_left) > GetHeight(node->m_right) ? \
 GetHeight(node->m_left) : GetHeight(node->m_right)) + 1;
    }

3. 先序、中序、后序（递归和非递归）以及层次遍历二叉树

3.1 前序遍历 

主要思路：根、左、右，需要栈保存扫描过的根

    void PreTraverse(TreeNode* node) 
    {
        if(node == NULL) return;
        cout << node->m_data <<",";
        PreTraverse(node->m_left);
        PreTraverse(node->m_right);
    }

    void PreTraverseWithoutRecursive(TreeNode* node) 
    {
        if(node == NULL) return;
        stack<TreeNode*> st;
        TreeNode* nd = node;
        while(nd || !st.empty()) {
            while(nd) {
                st.push(nd);
                cout << nd->m_data <<",";
                nd = nd->m_left;
            }
            TreeNode* tmpNode = st.top();
            st.pop();
            nd = tmpNode->m_right;
        }
    }

3.2 中序遍历

主要思路：左、根、右，需要栈保存扫描过的根

    void MidTraverse(TreeNode* node) 
    {
        if(node == NULL) return;
        MidTraverse(node->m_left);
        cout << node->m_data <<",";
        MidTraverse(node->m_right);
    }

    void MidTraverseWithoutRecursive(TreeNode* node) 
    {
        if(node == NULL) return ;
        stack<TreeNode*> st;
        TreeNode* nd = node;
        while(nd || !st.empty()) { //此处的判读条件
            while(nd) {
                st.push(nd);
                nd = nd->m_left;
            }
            TreeNode* tmpNode = st.top();
            st.pop();
            cout << tmpNode->m_data <<",";
            nd = tmpNode->m_right;//此处遍历栈顶弹出node
        }
    }

3.3 后序遍历

主要思路：

  1. 当节点的"右子树存在且被访问后"或者是"右子树为空"才能访问自身。
  2. 设置标志变量 flag 来判断是否访问过左孩子， pre指针来指向先前访问过的节点。
  3. 所有左孩子压栈后， 最后一个节点的左孩子为空，已被访问p = NULL ， 令flag=1

   当左孩子被访问时，进入循环，取栈顶节点。

  •     当栈顶节点的右孩子等于空或"前一个被访问的节点"时,访问该节点， 令pre 等于当前节点，pre = p， 当前节点出栈。
  •     当栈顶节点的右孩子不为空时， 继续遍历以右孩子为根节点的右子树。

    void PostTraverse(TreeNode* node) 
    {
        if(node == NULL) return;
        PostTraverse(node->m_left);
        PostTraverse(node->m_right);
        cout << node->m_data <<",";
    }

    
    void PostTraverseWithoutRecursive(TreeNode* node) 
    {
        if(node == NULL) return;
        stack<TreeNode*> st;
        int flag = 0;
        TreeNode* nd = node, *pre = NULL;
        do {
            while(nd) {
                st.push(nd);
                nd = nd->m_left;
            }

            flag = 1;
            while (!st.empty() && flag) {
                TreeNode* tempNode = st.top();
                if(tempNode->m_right ==  pre || !tempNode->m_right) {
                    cout << tempNode->m_data << ",";
                    st.pop();
                    pre = tempNode;
                } else {
                    nd = tempNode->m_right;
                    flag = 0;
                }
            }
        } while (!st.empty());
    }

    //后序遍历顺序：左右根 -> 变换：先获得根右左的遍历顺序，再反转
    void PostTraverseReverse(TreeNode* node) 
    {
        if(node == NULL) return;
        vector<int> res;
        stack<TreeNode*> st;
        TreeNode* nd = node;
        while(nd || !st.empty()) {
            while(nd) {
                st.push(nd);
                res.push_back(nd->m_data);
                nd = nd->m_right;
            }
            TreeNode* tmpNode = st.top();
            st.pop();
            nd = tmpNode->m_left;
        }

        for (int i = res.size() -1 ; i >= 0; i--) {
            cout << res[i] << ",";
        }
        cout << endl;
    }

3.4 层次遍历

   void TreeLevelTraverse(TreeNode* node) 
    {
        if(node == NULL) return ;

        queue<TreeNode*> que;
        que.push(node);
        while(!que.empty()) {
            TreeNode* tmpNode = que.front();
            cout << tmpNode->m_data <<",";
            que.pop();
            if(tmpNode->m_left) que.push(tmpNode->m_left);
            if(tmpNode->m_right) que.push(tmpNode->m_right);
        }
    }

4. 树向右拉平

主要思路：从根节点开始出发，先检测其左子结点是否存在，如存在则将根节点和其右子节点断开，将左子结点及其后面所有结构一起连到原右子节点的位置，把原右子节点连到元左子结点最后面的右子节点之后。

    void flatten(TreeNode *root) 
    {
        TreeNode *cur = root;
        while (cur) {
            if (cur->m_left) {
                TreeNode *p = cur->m_left;
                while (p->m_right) p = p->m_right;
                p->m_right = cur->m_right;
                cur->m_right = cur->m_left;
                cur->m_left = NULL;
            }
            cur = cur->m_right;
        }
    }

5. 树的右视图 

主要思路：层次遍历只取最右边的孩子, 统计每一层的节点个数，循环将他们的左右孩子入队，最后只保存这一次最右边的孩子的值

    vector<int> rightSideView(TreeNode *root) 
    {
        vector<int> res;
        if (!root) return res;
        queue<TreeNode*> q;
        q.push(root);
        while (!q.empty()) {
	      res.push_back(q.back()->m_data);
	      int size = q.size();
	      for (int i = 0; i < size; ++i) {
	        TreeNode *node = q.front();
	        q.pop();
	        if (node->m_left) q.push(node->m_left);
	        if (node->m_right) q.push(node->m_right);
	      }
        }
        return res;
    }

 6. 树的左右镜像

    TreeNode* switchTree(TreeNode* root) {
        if(NULL == root) return NULL;

        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()) {
            TreeNode* tn = st.top(); st.pop();
            TreeNode* tmp = tn->m_left;
            tn->m_left = tn->m_right;
            tn->m_right = tmp;
            if(tn->m_left) st.push(tn->m_left);
            if(tn->m_right) st.push(tn->m_right);
        }
        return root;
    }

 

附录：整个工程代码

#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <algorithm>
using namespace std;

struct TreeNode 
{
    int m_data;
    TreeNode* m_left;
    TreeNode* m_right;
};

class Tree 
{
private:
    TreeNode* m_root;
    int m_height;
public:
    ~Tree() { }
    Tree() { m_root = NULL; m_height = 0; }

    TreeNode* GetRoot() { return m_root;}

    TreeNode* BuildTree(vector<int>& pre, vector<int>& in)
    {

        if (pre.size() == 0 || pre.size() != in.size()) return NULL;

        m_root = BuildTreeInternal(pre, 0, pre.size() - 1, in, 0, in.size() - 1);

        return m_root;
    }

    TreeNode* BuildTreeInternal(vector<int>& pre, int ps, int pe, vector<int>& in, int is, int ie) 
    {

        if ( ps > pe && is > ie ) return NULL;

        int data = pre[ps];
        int mid = 0;
        vector<int>::iterator it = find(in.begin(), in.end(), data);

        if (it != in.end()) mid = it - in.begin();
        int llen = mid - is; //说明要以当前root为根节点对需要建树的序列b左子树长
        int rlen = ie - mid; //说明要以当前root为根节点对需要建树的序列b右子树长

        TreeNode* tn = new TreeNode();
        tn->m_data = data;
        tn->m_left = BuildTreeInternal(pre, ps + 1, ps + llen, in, is, is + llen -1);
        tn->m_right = BuildTreeInternal(pre, pe - rlen + 1, pe, in, ie - rlen + 1, ie);

        return tn;
    }

    void PreTraverse(TreeNode* node) 
    {
        if(node == NULL) return;
        cout << node->m_data <<",";
        PreTraverse(node->m_left);
        PreTraverse(node->m_right);
    }

    void PreTraverseWithoutRecursive(TreeNode* node) {
        if(node == NULL) return;
        stack<TreeNode*> st;
        TreeNode* nd = node;
        while(nd || !st.empty()) {
            while(nd) {
                st.push(nd);
                cout << nd->m_data <<",";
                nd = nd->m_left;
            }
            TreeNode* tmpNode = st.top();
            st.pop();
            nd = tmpNode->m_right;
        }
    }

    void MidTraverse(TreeNode* node) 
    {
        if(node == NULL) return;
        MidTraverse(node->m_left);
        cout << node->m_data <<",";
        MidTraverse(node->m_right);
    }

    map<string, vector<int> >  MidTraverseWithoutRecursive(TreeNode* node) 
    {
        map<string, vector<int> > ret;
        if(node == NULL) return ret;
        vector<int> res;
        stack<TreeNode*> st;
        TreeNode* nd = node;
        while(nd || !st.empty()) { //此处的判读条件
            while(nd) {
                st.push(nd);
                nd = nd->m_left;
            }
            TreeNode* tmpNode = st.top();
            st.pop();
            res.push_back(tmpNode->m_data);
            //cout << tmpNode->m_data <<",";
            nd = tmpNode->m_right;//此处遍历栈顶弹出node
        }
        ret.insert(pair<string, vector<int> >(__FUNCTION__, res));
        return ret;
    }

    void PostTraverse(TreeNode* node) 
    {
        if(node == NULL) return;
        PostTraverse(node->m_left);
        PostTraverse(node->m_right);
        cout << node->m_data <<",";
    }

/*后续遍历关键在于，当节点的"右子树存在且被访问后"或者是"右子树为空"才能访问自身。
设置标志变量 flag 来判断是否访问过左孩子， pre指针来指向先前访问过的节点。
所有左孩子压栈后， 最后一个节点的左孩子为空，已被访问p = NULL ， 令flag=1
当左孩子被访问时，进入循环，取栈顶节点。
1. 当栈顶节点的右孩子 等于 空  或  前一个被访问的节点  时， 访问该节点， 令pre 等于当前节点，pre = p， 当前节点出栈。
2. 当栈顶节点的右孩子不为空时， 继续遍历以右孩子为根节点的右子树。
*/
    void PostTraverseWithoutRecursive(TreeNode* node) 
    {
        if(node == NULL) return;
        stack<TreeNode*> st;
        int flag = 0;
        TreeNode* nd = node, *pre = NULL;
        do {
            while(nd) {
                st.push(nd);
                nd = nd->m_left;
            }

            flag = 1;
            while (!st.empty() && flag) {
                TreeNode* tempNode = st.top();
                if(tempNode->m_right ==  pre || !tempNode->m_right) {
                    cout << tempNode->m_data << ",";
                    st.pop();
                    pre = tempNode;
                } else {
                    nd = tempNode->m_right;
                    flag = 0;
                }
            }
        } while (!st.empty());
    }

    //后序遍历顺序：左右根 -> 变换：先获得根右左的遍历顺序，再反转
    void PostTraverseReverse(TreeNode* node) 
    {
        if(node == NULL) return;
        vector<int> res;
        stack<TreeNode*> st;
        TreeNode* nd = node;
        while(nd || !st.empty()) {
            while(nd) {
                st.push(nd);
                res.push_back(nd->m_data);
                nd = nd->m_right;
            }
            TreeNode* tmpNode = st.top();
            st.pop();
            nd = tmpNode->m_left;
        }

        for (int i = res.size() -1 ; i >= 0; i--) {
            cout << res[i] << ",";
        }
        cout << endl;
    }

    int GetHeight(TreeNode* node) 
    {
        if(node == NULL) return 0;
        return (GetHeight(node->m_left) > GetHeight(node->m_right) ? GetHeight(node->m_left) : GetHeight(node->m_right)) + 1;
    }

    void TreeLevelTraverse(TreeNode* node) 
    {
        if(node == NULL) return ;

        queue<TreeNode*> que;
        que.push(node);
        while(!que.empty()) {
            TreeNode* tmpNode = que.front();
            cout << tmpNode->m_data <<",";
            que.pop();
            if(tmpNode->m_left) que.push(tmpNode->m_left);
            if(tmpNode->m_right) que.push(tmpNode->m_right);
        }
    }

    vector<int> RightSideView(TreeNode *root)
    {
        vector<int> res;
        if (!root) return res;
        queue<TreeNode*> q;
        q.push(root);
        while (!q.empty()) {
            res.push_back(q.back()->m_data);
            int size = q.size();
            for (int i = 0; i < size; ++i) {
                TreeNode *node = q.front();
                q.pop();
                if (node->m_left) q.push(node->m_left);
                if (node->m_right) q.push(node->m_right);
            }
        }
        return res;
    }

    void LeftFlattenTree(TreeNode *root)
    {
        TreeNode *cur = root;
        while (cur) {
            if (cur->m_left) {
                TreeNode *p = cur->m_left;
                while (p->m_right) p = p->m_right;
                p->m_right = cur->m_right;
                cur->m_right = cur->m_left;
                cur->m_left = NULL;
            }
            cur = cur->m_right;
        }
    }

    void showTree(map<string, vector<int> > data) 
    {
        if(data.empty()) return;
        map<string,vector<int> >::iterator it = data.begin();
        cout << it->first << ":" <<endl;
        vector<int>::iterator vit = it->second.begin();
        while (vit != it->second.end()) {
            cout << *vit++ << ",";
        }
    }

    void PrintTree(TreeNode* n, bool left, string const& indent)
    {
        if (n->m_right)
        {
            PrintTree(n->m_right, false, indent + (left ? "|     " : "      "));
        }
        cout << indent;
        cout << (left ? '\\' : '/');
        cout << "-----";
        cout << n->m_data << endl;
        if (n->m_left)
        {
            PrintTree(n->m_left, true, indent + (left ? "      " : "|     "));
        }
    }

    void Print(TreeNode* root)
    {
        if (root->m_right)
        {
            PrintTree(root->m_right, false, "");
        }
        cout << root->m_data << endl;
        if (root->m_left)
        {
            PrintTree(root->m_left, true, "");
        }
    }
};

void printVector(int tag, vector<int>& vec) 
{
    int i = 0;
    switch(tag) {
    case 1:
        cout << "PreTraverse..."<<endl;
        break;
    case 2:
        cout << "MidTraverse..."<<endl;
        break;
    case 3:
        cout << "PostTraverse..."<<endl;
        break;
    default:
        break;
    }
    for(i = 0; i < vec.size() - 1; i++) {
        cout << vec[i] <<" , ";
    }
    cout << vec[vec.size() - 1] << endl;
}



int main()
{
    int a[] = {1, 2, 9, 12, 13, 14, 10, 11, 15, 3, 4, 5, 6, 7, 8};
    int b[] = {13, 12, 14, 9, 2, 11, 15, 10, 1, 3, 5, 4, 7, 6, 8};
    vector<int> pre(a, a + sizeof(a)/sizeof(a[0]));
    vector<int> ldr(b, b + sizeof(b)/sizeof(b[0]));
    printVector(1, pre);
    printVector(2, ldr);
    cout <<endl;
    Tree* tr = new Tree();
    tr->CreateTree(pre, ldr);
    tr->Print(tr->GetRoot());
    tr->BuildTreeInplace(pre, ldr);
    tr->Print(tr->GetRoot());
    cout << endl << "Pre Traverse:" << endl;;
    tr->PreTraverse(tr->GetRoot());
    cout << endl;
    tr->PreTraverseWithoutRecursive(tr->GetRoot());
    cout << endl << endl << "Mid Traverse:" << endl;
    tr->MidTraverse(tr->GetRoot());
    cout << endl;
    tr->showTree(tr->MidTraverseWithoutRecursive(tr->GetRoot()));
    cout << endl << endl << "Post Traverse:" << endl;
    tr->PostTraverse(tr->GetRoot());
    cout << endl;
    tr->PostTraverseWithoutRecursive(tr->GetRoot());
    cout << endl;
    tr->PostTraverseReverse(tr->GetRoot());
    cout << endl;
    cout <<"Tree Height:" << tr->GetHeight(tr->GetRoot());
    cout << endl << endl << "Level Traverse:" << endl;
    tr->TreeLevelTraverse(tr->GetRoot());
    cout << endl << endl << "Tree Left View:" << endl;
    vector<int> ret = tr->RightSideView(tr->GetRoot());
	for(auto item: ret) cout << item << ", ";
    cout << endl;
    cout << endl << endl << "Tree Left Flatten View:" << endl;
    tr->LeftFlattenTree(tr->GetRoot());
    tr->Print(tr->GetRoot());
    return 1;
}

执行结果

PreTraverse...
1 , 2 , 9 , 12 , 13 , 14 , 10 , 11 , 15 , 3 , 4 , 5 , 6 , 7 , 8
MidTraverse...
13 , 12 , 14 , 9 , 2 , 11 , 15 , 10 , 1 , 3 , 5 , 4 , 7 , 6 , 8

                  /-----8
            /-----6
            |     \-----7
      /-----4
      |     \-----5
/-----3
1
|     /-----10
|     |     |     /-----15
|     |     \-----11
\-----2
      \-----9
            |     /-----14
            \-----12
                  \-----13

Pre Traverse:
1,2,9,12,13,14,10,11,15,3,4,5,6,7,8,
1,2,9,12,13,14,10,11,15,3,4,5,6,7,8,

Mid Traverse:
13,12,14,9,2,11,15,10,1,3,5,4,7,6,8,
MidTraverseWithoutRecursive:
13,12,14,9,2,11,15,10,1,3,5,4,7,6,8,

Post Traverse:
13,14,12,9,15,11,10,2,5,7,8,6,4,3,1,
13,14,12,9,15,11,10,2,5,7,8,6,4,3,1,
13,14,12,9,15,11,10,2,5,7,8,6,4,3,1,

Tree Height:5

Level Traverse:
1,2,3,9,10,4,12,11,5,6,13,14,15,7,8,

Tree Left View:
1, 3, 4, 6, 8,


Tree Left Flatten View:
                                                                              /-----8
                                                                        /-----7
                                                                  /-----6
                                                            /-----5
                                                      /-----4
                                                /-----3
                                          /-----15
                                    /-----11
                              /-----10
                        /-----14
                  /-----13
            /-----12
      /-----9
/-----2
1

 

哲米
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树的基本算法(C语言版）
想当厨子的程序媛
01-06 1108
先序次序创建二叉树 status CreateBiTree(BiTree &T) { char a; scanf("%c",&a); if(a=='#') T=null; else { T=(BiTNode)malloc(sizeof(BiNode)); if(!T) exit(0);
c语言实现数据结构--树
bhbca的博客
01-17 1948
C语言实现树
C语言树的简单实现和相关算法
M.JH的博客
05-20 219
#include<stdio.h> #include<stdlib.h> #include<time.h> #define maxSize 10 typedef struct BTNode { char data; struct BTNode* lchild; struct BTNode* rchild; }BTNode; void init(BTNode**T) { (*T) = (BTNode*)malloc(sizeof(BTNode)); (*T)-&
基础数据结构与算法之树-C语言实现
DanielSYC的博客
10-07 371
二叉树 二叉搜索树 平衡二叉树 堆 哈夫曼树 并查集
c语言树数据结构
qq_44940648的博客
06-22 830
树型结构是以分支关系定义的层次结构，它是一种重要的非线性结构。 在计算机科学中，树（英语：tree）是一种抽象数据类型（ADT）或是实现这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n（n>0）个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 每个节点都只有有限个子节点或无子节点； 没有父节点的节点称为根节点； 每一个非根节点有且只有一个父节点； 除了根节点外，每个子节点可以分为多个不相交的子树
Apriori算法和FP-Tree算法简介
01-07
为了克服 Apriori 算法在复杂度和效率方面的缺陷，本节还进一步的介绍了基于 FP-Tree 的频繁模式挖掘方法。 Apriori关联分析算法 Apriori 算法是挖掘产生关联规则所需频繁项集的基本算法，也是最著名的关联分析算法...
构建sp-tree
09-24
在对数据处理时通过构建sp-tree，能够加快查询、删除和查找等操作。相对于传统的R树、R*树，sp-tree能够有效的减小处理数据是的复杂度。
dbscan:基于Kd-tree最近邻居搜索的快速dbscan算法
05-12
基于密度的带噪声应用程序空间聚类（DBSCAN） 基于Kd-tree最近邻居搜索的快速dbscan算法调用方式： double eps = 0.02 ; // radius of searchingint minPts = 1 ; // minimus points numberDbscan< Clusterable> ...
IQ-TREE:高效的植物遗传学软件
05-14
智商树 通过最大可能高效，通用的系统植物学软件介绍IQ-TREE软件是IQPNNI和 （因此称为IQ-TREE）的后继...IQ-TREE的主要功能高效的搜索算法：快速有效的随机算法，以最大的可能性重建系统树。 IQ-TREE在可能性上优于
C/C++，树算法-K叉树（k-dimensional-tree）的计算方法与源代码
最新发布
05-14
C/C++，树算法——K叉树（k-dimensional-tree）的计算方法与源代码
字典树算法 c语言实现
11-28
用C语言实现的字典树算法，用C语言实现的字典树算法。
【数据结构与算法】树(Tree)【详解】
DreamSun的博客
03-25 3992
【知识框架】树是n（n>=0）个结点的有限集。当n = 0时，称为空树。有且仅有一个特定的称为根的结点。当n>1时，其余节点可分为m（m>0）个互不相交的有限集T1,T2,…,Tm，其中每个集合本身又是一棵树，并且称为根的子树。显然，树的定义是递归的，即在树的定义中又用到了自身，树是一种递归的数据结构。树的根结点没有前驱，除根结点外的所有结点有且只有一个前驱。树中所有结点可以有零个或多个后继。因此n个结点的树中有n-1条边。
数据结构与算法：树（Tree）
SHZNIU的博客
03-04 2730
树： 是n个节点的有限集，由一个根节点和若干个子树构成。和我们生活中的树结构相似，n>0时根节点是唯一的，不能存在多个根节点。其中子树没有限制可以有多个，但是子树一定不相交。 二叉树： 是由一个根节点和两颗互不相交的分别称为根节点的左子树和右子树的二叉树组成。二叉树的每个节点最多有两个子节点，分别是左子节点和右子节点。二叉树中，有两种比较特殊的树，分别是满二叉树和完全二叉树。满二叉树又是完全二叉树的一种特殊情况。数组插入时左子节点要小于父节点，右子节点要大于父节点。 完全二叉树： 即所有的编号都要连续
数据结构与算法Python（树与树算法）
Bro_Jun的博客
04-11 253
目录树树的概念、特点二叉树二叉树的实现节点的创建树的创建添加节点广度遍历三种深度遍历 树 树的概念、特点 树（英语：tree）是一种抽象数据类型（ADT）或是实作这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n（n>=1）个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 每个节点有零...
KD——Tree算法+原理简单理解
luobicangqiong的博客
03-22 1693
       KD树是用于一种分割k维数据空间的数据结构。它是由最基本的二叉树发展而来的。采用递归的方法对数据进行分割。在计算机视觉进行特征匹配，寻找近邻时通常会用到KD树。      在具体介绍KD树。我们先来了解一下二叉树。对于一维数据的划分我们通常使用它。二叉树具有如下的性质： 若它的左子树不为空，则它的左子树节点上的值皆小于它的根节点。若它的右子树不为空，则它的右子树节点上的值皆大于它的根...
算法入门——树（基础篇）（tree）
m0_60343477的博客
11-09 611
层次遍历的规律是先进先出，后进后出。由于始终希望越是上层的根节点处理的越晚，所以应该将最开始的根节点压入栈。根据栈先进后出，后进先出的严格规律，后处理的先放入，先处理的后放入。上面三条规律是非常容易找到的，那么如何右它去创建一个二叉树呢？从栈顶开始，每当栈顶元素的孩子节点处理完，那么将栈顶元素出栈。从根节点开始，每当当前节点有孩子节点，那么将当前节点入栈。层次遍历：一层一层遍历，规定每一次的遍历顺序是从左到右。左孩子->根节点->右孩子。左孩子->右孩子->根节点。前序遍历：根->左->右。
Trie树
weixin_63215693的博客
08-01 62
并查集
Tree树及其相关代码的实现(1)
yyb0802的博客
10-28 1640
树是一种基本的数据结构，可以使用线性表进行存储，但往往因为过于复杂而不得不定义两个指针。其次树最常用的是二叉树，树的主要作用是查找。AVL树，最优二叉树，搜索二叉树等都是常用的搜索类型，因树的数据结构过于繁杂，故今天先用以下三个功能来进行说明 分别是创建新节点，查找功能（外加改变相对应的值）和插入功能 #include using namespace std; typedef int T
随机树生成模型
baozhiqiangjava的博客
05-31 996
了解当前随机树生成的方向，关心其概率分布。 1 定义
FP-tree算法实验目的
12-07
很抱歉，引用内容中没有提到FP-tree算法的实验目的。但是，根据FP-tree算法的原理和应用场景，可以猜测FP-tree算法的实验目的可能是： 1. 通过实验验证FP-tree算法相对于Apriori算法的效率和性能优势。 2. 探究FP-...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值