第十章 基本数据结构——二叉树

最新推荐文章于 2024-10-31 21:13:19 发布
最新推荐文章于 2024-10-31 21:13:19 发布
阅读量109 收藏
点赞数
文章标签： 数据结构与算法 c/c++

可以参考：http://www.cnblogs.com/dolphin0520/archive/2011/08/25/2153720.html

摘要

　　书中第10章10.4小节介绍了有根树，简单介绍了二叉树和分支数目无限制的有根树的存储结构，而没有关于二叉树的遍历过程。为此对二叉树做个简单的总结，介绍一下二叉树基本概念、性质、二叉树的存储结构和遍历过程，主要包括先根遍历、中根遍历、后根遍历和层次遍历。

1、二叉树的定义

　　二叉树（Binary Tree）是一种特殊的树型结构，每个节点至多有两棵子树，且二叉树的子树有左右之分，次序不能颠倒。

　　由定义可知，二叉树中不存在度（结点拥有的子树数目）大于2的节点。二叉树形状如下下图所示：

2、二叉树的性质

（1）在二叉树中的第i层上至多有2^(i-1)个结点（i>=1)。备注:^表示此方

（2）深度为k的二叉树至多有2^k-1个节点（k>=1)。

（3）对任何一棵二叉树T，如果其终端结点数目为n0，度为2的节点数目为n2，则n0=n2+1。

满二叉树：深度为k且具有2^k-1个结点的二叉树。即满二叉树中的每一层上的结点数都是最大的结点数。

完全二叉树：深度为k具有n个结点的二叉树，当且仅当每一个结点与深度为k的满二叉树中的编号从1至n的结点一一对应。

可以得到一般结论：满二叉树和完全二叉树是两种特殊形态的二叉树，满二叉树肯定是完全二叉树，但完全二叉树不不一定是满二叉树。

举例如下图是所示：

（4）具有n个节点的完全二叉树的深度为log2n + 1。

3、二叉树的存储结构

　　可以采用顺序存储数组和链式存储二叉链表两种方法来存储二叉树。经常使用的二叉链表方法，因为其非常灵活，方便二叉树的操作。二叉树的二叉链表存储结构如下所示：

//二叉树的数据结构
typedef struct binary_tree_node
{
    int elem;
    struct binary_tree_node *left;
    struct binary_tree_node *right;
}binary_tree_node,*binary_tree;

举例说明二叉链表存储过程，如下图所示：

从图中可以看出：在还有n个结点的二叉链表中有n+1个空链域。

 

4、遍历二叉树

　　遍历二叉树是按照指定的路径方式访问书中每个结点一次，且仅访问一次。由二叉树的定义，我们知道二叉数是由根结点、左子树和右子树三部分构成的。通常遍历二叉树是从左向右进行，因此可以得到如下最基本的三种遍历方法：

（1）先根遍历（先序遍历）：如果二叉树为空，进行空操作；否则，先访问根节点，然后先根遍历左子树，最后先根遍历右子树。采用递归形式实现代码如下：

//前序遍历递归版
void preorder_traverse_recursive(binary_tree root)
{
    if(root!=NULL)
    {
        cout<<root->elem<<endl;
        preorder_traverse_recursive(root->left);
        preorder_traverse_recursive(root->right);
    }
}

具体过程如下图所示：

（2）中根遍历（中序遍历）：如果二叉树为空，进行空操作；否则，先中根遍历左子树，然后访问根结点，最后中根遍历右子树。递归过程实现代码如下：

//中序遍历递归版
void inorder_traverse_recursive(binary_tree root)
{
    if(root!=NULL)
    {
        inorder_traverse_recursive(root->left);
        cout<<root->elem<<endl;
        inorder_traverse_recursive(root->right);
    }
}

具体过程如下图所示：

（3）后根遍历（后序遍历）：如果二叉树为空，进行空操作；否则，先后根遍历左子树，然后后根遍历右子树，最后访问根结点。递归实现代码如下：

//后序遍历递归版
void postorder_traverse_recursive(binary_tree root)
{
    if(root!=NULL)
    {
        postorder_traverse_recursive(root->left);
        postorder_traverse_recursive(root->right);
        cout<<root->elem<<endl;
    }
}

具体过程如下图所示：

　　写一个完整的程序练习二叉树的三种遍历，采用递归形式创建二叉树，然后以递归的形式遍历二叉树，后面会接着讨论如何使用非递归形式实现这三种遍历，程序采用C++语言实现，完整程序如下：

#include<iostream>
#include<cstdlib>
using namespace std;


//二叉树的数据结构
typedef struct binary_tree_node
{
    int elem;
    struct binary_tree_node *left;
    struct binary_tree_node *right;
}binary_tree_node,*binary_tree;

//前序遍历递归版
void preorder_traverse_recursive(binary_tree root)
{
    if(root!=NULL)
    {
        cout<<root->elem<<endl;
        preorder_traverse_recursive(root->left);
        preorder_traverse_recursive(root->right);
    }
}

//中序遍历递归版
void inorder_traverse_recursive(binary_tree root)
{
    if(root!=NULL)
    {
        inorder_traverse_recursive(root->left);
        cout<<root->elem<<endl;
        inorder_traverse_recursive(root->right);
    }
}

//后序遍历递归版
void postorder_traverse_recursive(binary_tree root)
{
    if(root!=NULL)
    {
        postorder_traverse_recursive(root->left);
        postorder_traverse_recursive(root->right);
        cout<<root->elem<<endl;
    }
}

//初始化二叉树
void init_binary_tree(binary_tree *root)
{
    *root=NULL;
}

//方法一：创建二叉树，注意传入的参数是二级指针，否则不能运行正确结果
/*void create_binary_tree(binary_tree *root)
{
    int elem;
    cout<<"Enter the node value (0 is end): ";
    cin>>elem;
    if(elem==0)
        *root=NULL;
    else
    {
        *root=(binary_tree)malloc(sizeof(binary_tree_node));
        if(*root==NULL)
        {
            cout<<"malloc error"<<endl;
            exit(1);
        }
        (*root)->elem=elem;
        cout<<"creating the left child node"<<endl;
        create_binary_tree(&((*root)->left));
        cout<<"creating the right child node"<<endl;
        create_binary_tree(&((*root)->right));
    }
}*/
//方法二
binary_tree create_binary_tree()
{
    int elem;
    binary_tree root;
    cout<<"Enter the node value (0 is end): ";
    cin>>elem;
    if(elem==0)
        root=NULL;
    else
    {
        //在堆空间分配的内存，可以返回局部对象
        root=(binary_tree)malloc(sizeof(binary_tree_node));
        if(root==NULL)
        {
            cout<<"malloc error"<<endl;
            exit(1);
        }
        (root)->elem=elem;
        cout<<"creating the left child node"<<endl;
        root->left=create_binary_tree();
        cout<<"creating the right child node"<<endl;
        root->right=create_binary_tree();
    }
    return root;
}

int main()
{
    binary_tree root;
    init_binary_tree(&root);
    root=create_binary_tree();
    preorder_traverse_recursive(root);
    inorder_traverse_recursive(root);
    postorder_traverse_recursive(root);
    exit(0);
}
View Code

 运行结果如下：

其中，两种创建方式以及为什么要传递二级指针，可以参考http://tieba.baidu.com/p/228434573#

 现在来讨论一下如何采用非递归实现这以上三种遍历。将递归形式转换为非递归形式，引入了额外的辅助结构栈。另外在讨论一次二叉树的层次遍历，可以借助队列进行实现。具体讨论如下：

先序遍历，其实过程很简单：一直往左走 root->left->left->left...->null，由于是先序遍历，因此一遇到节点，便需要立即访问；由于一直走到最左边后，需要逐步返回到父节点访问右节点，因此必须有一个措施能够对节点序列回溯。有两个办法：
1.用栈记忆：在访问途中将依次遇到的节点保存下来。由于节点出现次序与恢复次序是反序的，因此是一个先进后出结构，需要用栈。
使用栈记忆的实现有两个版本。第一个版本是模拟递归的实现效果，跟LX讨论的，第二个版本是直接模拟递归。
2.节点增加指向父节点的指针：通过指向父节点的指针来回溯（后来发现还要需要增加一个访问标志，来指示节点是否已经被访问，不知道可不可以不用标志直接实现回溯？想了一下，如果不用这个标志位，回溯的过程会繁琐很多。暂时没有更好的办法。

先序遍历C++代码：非递归版本，用栈实现，版本1

//非递归先序遍历,使用栈实现，版本一
void preorder_traverse(binary_tree root)
{
    stack<binary_tree> s;
    if(root!=NULL)
    {
        s.push(root);
        binary_tree tmpnode;
        while(!s.empty())
        {
            tmpnode=s.top();
            cout<<tmpnode->elem<<endl; // 先访问根节点，然后根节点就无需入栈了
            s.pop();
            // 先push的是右节点，再是左节点
            if(tmpnode->right)
                s.push(tmpnode->right);
            if(tmpnode->left)
                s.push(tmpnode->left);
        }
    }
}

每次将节点压入栈，然后弹出，压右子树，再压入左子树，在遍历过程中，遍历序列的右节点依次被存入栈，左节点逐次被访问。同一时刻，栈中元素为m-1个右节点和1个最左节点，最高为h。所以空间也为O(h)；每个节点同样被压栈一次，弹栈一次，访问一次，时间复杂度O(n)。

先序遍历代码：非递归版本，用栈实现，版本2

//非递归实现先序遍历，使用栈实现，版本二
void preorder_traverse(binary_tree root)
{
    stack<binary_tree> s;
    while(root||!s.empty())
    {
        if(root)
        {
            cout<<root->elem<<endl;// 先序就体现在这里了，先访问，再入栈
            s.push(root);
            root=root->left;// 依次访问左子树
        }
        else
        {
            root=s.top();// 回溯至父亲节点
            s.pop();
            root=root->right;
        }
    }
}

每次都将遇到的节点压入栈，当左子树遍历完毕后才从栈中弹出最后一个访问的节点，访问其右子树。在同一层中，不可能同时有两个节点压入栈，因此栈的大小空间为O(h)，h为二叉树高度。时间方面，每个节点都被压入栈一次，弹出栈一次，访问一次，复杂度为O(n)。

（2）中根遍历非递归实现

　　中根遍历要求顺序是左根右，借助栈s实现。先将根root入栈，接着从根root开始查找最左的子孩子结点直到为空为止，再将左子树节点出栈遍历，然后判断该左子树的右子树节点入栈。循环此过程，直到栈为空为止。采用C++中模板库stack实现先根遍历如下：

//非递归实现中序遍历，使用栈实现
void inorder_traverse(binary_tree root)
{
    stack<binary_tree> s;
    while(root||!s.empty())
    {
        if(root)
        {
            s.push(root);
            root=root->left;
        }
        else
        {
            root=s.top();
            cout<<root->elem<<endl;
            s.pop();
            root=root->right;
        }
    }
}

根据上面的先序遍历，可以类似的构造出中序遍历。仔细想一下，只有第2种方法改过来时最方便的。需要的改动仅仅调换一下节点访问的次序，先序是先访问，再入栈；而中序则是先入栈，弹栈后再访问。

（3）后根遍历递归实现

　　后根遍历要求访问顺序是左右根，采用辅助栈实现时，需要一个标记，判断结点是否访问了，因为右子树是通过跟结点的信息得到的。实现过程是先将根结点及其左子树入栈，并初始标记为0，表示没有访问，然后通过判断栈是否为空和标记的值是否为1来判断是否访问元素。

参考：http://www.cnblogs.com/hicjiajia/archive/2010/08/27/1810055.html

采用C++模板库stack具体实现程序如下：

void postorder_traverse(binary_tree root)
{
    if(NULL != root)
    {
        stack<binary_tree_node*> s;
        binary_tree_node *ptmpnode;
        int flags[100];
        ptmpnode = root;
        while(NULL != ptmpnode || !s.empty())
        {
            //将结点左子树结点入栈
            while(NULL != ptmpnode)
            {
                s.push(ptmpnode);
                flags[s.size()] = 0;   //标记未访问
                ptmpnode=ptmpnode->left;
            }
            //输出访问的结点
            while(!s.empty() && flags[s.size()] == 1)
            {
                ptmpnode = s.top();
                s.pop();
                cout<<ptmpnode->elem<<" ";
            }
            //从右子树开始遍历
            if(!s.empty())
            {
                ptmpnode = s.top();
                flags[s.size()] = 1;  //登记访问了
                ptmpnode = ptmpnode->right;
            }
            else
                break;
        }
    }
}

一种更简单的实现，第二种思路：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

//非递归后序遍历，使用栈实现
void postorder_traverse(binary_tree root)
{
    binary_tree curr; //当前结点
    binary_tree pre=NULL; //上一次访问的结点
    stack<binary_tree> s;
    if(root)
        s.push(root);
    while(!s.empty())
    {
        curr=s.top();
        //如果当前结点没有孩子结点或者孩子节点都已被访问过 
        if((curr->left==NULL&&curr->right==NULL)||(pre!=NULL&&(pre==curr->left||pre==curr->right)))
        {
            cout<<curr->elem<<endl;
            s.pop();
            pre=curr;
        }
        else
        {
            if(curr->right)
                s.push(curr->right);
            if(curr->left)
                s.push(curr->left);
        }
    }
}

对于判断条件if((curr->left==NULL&&curr->right==NULL)||(pre!=NULL&&(pre==curr->left||pre==curr->right)))的第二部分，开始我没了解，后来想想好像是当前访问结点之前的访问结点只有两种情况，如果当前访问结点存在右子树，则上一次的访问结点pre只能是右子树，否则，就是左子树了。所以，如果满足条件pre!=NULL&&pre==curr->left，说明当前结点不存在右子树，所以不需要判断右子树是否被访问了。否则就是左右子树都被访问了。

（4）层次遍历实现

　　层次遍历要求从根向下、从左向右进行访问，可以采用队列实现。先将根入队，然后队列进程出队操作访问结点p，再将结点p的左子树和右子树结点入队，循环执行此过程直到队列为空。出队顺序即是层次遍历结果。采用C++的模板库queue实现如下：

//层次遍历
void levelorder_traverse(binary_tree root)
{
    queue<binary_tree> q;
    binary_tree tmpnode;
    if(root)
        q.push(root);
    while(!q.empty())
    {
        tmpnode=q.front();
        cout<<tmpnode->elem<<" ";
        q.pop();
        if(tmpnode->left)
            q.push(tmpnode->left);
        if(tmpnode->right)
            q.push(tmpnode->right);
    }
}

 综合上面的分析过程写个完整的程序测试二叉树遍历的非递归实现，采用C++语言，借助stack和queue实现，完整程序如下所示：

#include<iostream>
#include<stack>
#include<queue>
#include<cstdlib>
using namespace std;

typedef struct binary_tree_node
{
    int elem;
    struct binary_tree_node *left;
    struct binary_tree_node *right;
}binary_tree_node,*binary_tree;

//非递归先序遍历,使用栈实现，版本一
/*void preorder_traverse(binary_tree root)
{
    stack<binary_tree> s;
    if(root!=NULL)
    {
        s.push(root);
        binary_tree tmpnode;
        while(!s.empty())
        {
            tmpnode=s.top();
            cout<<tmpnode->elem<<" ";
            s.pop();
            if(tmpnode->right)
                s.push(tmpnode->right);
            if(tmpnode->left)
                s.push(tmpnode->left);
        }
    }
}*/
//非递归实现先序遍历，使用栈实现，版本二
void preorder_traverse(binary_tree root)
{
    stack<binary_tree> s;
    while(root||!s.empty())
    {
        if(root)
        {
            cout<<root->elem<<" ";
            s.push(root);
            root=root->left;
        }
        else
        {
            root=s.top();
            s.pop();
            root=root->right;
        }
    }
}

//非递归实现中序遍历，使用栈实现
void inorder_traverse(binary_tree root)
{
    stack<binary_tree> s;
    while(root||!s.empty())
    {
        if(root)
        {
            s.push(root);
            root=root->left;
        }
        else
        {
            root=s.top();
            cout<<root->elem<<" ";
            s.pop();
            root=root->right;
        }
    }
}

//非递归后序遍历，使用栈实现
void postorder_traverse(binary_tree root)
{
    binary_tree curr;//当前结点
    binary_tree pre=NULL; //前一次访问的结点
    stack<binary_tree> s;
    if(root)
        s.push(root);
    while(!s.empty())
    {
        curr=s.top();
        if((curr->left==NULL&&curr->right==NULL)||(pre!=NULL&&(pre==curr->left||pre==curr->right)))
        {
            cout<<curr->elem<<" ";
            s.pop();
            pre=curr;
        }
        else
        {
            if(curr->right)
                s.push(curr->right);
            if(curr->left)
                s.push(curr->left);
        }
    }
}

//层次遍历
void levelorder_traverse(binary_tree root)
{
    queue<binary_tree> q;
    binary_tree tmpnode;
    if(root)
        q.push(root);
    while(!q.empty())
    {
        tmpnode=q.front();
        cout<<tmpnode->elem<<" ";
        q.pop();
        if(tmpnode->left)
            q.push(tmpnode->left);
        if(tmpnode->right)
            q.push(tmpnode->right);
    }
}
//初始化二叉树
void init_binary_tree(binary_tree *root)
{
    *root=NULL;
}

//方法一：创建二叉树，注意传入的参数是二级指针，否则不能运行正确结果
/*void create_binary_tree(binary_tree *root)
{
    int elem;
    cout<<"Enter the node value (0 is end): ";
    cin>>elem;
    if(elem==0)
        *root=NULL;
    else
    {
        *root=(binary_tree)malloc(sizeof(binary_tree_node));
        if(*root==NULL)
        {
            cout<<"malloc error"<<endl;
            exit(1);
        }
        (*root)->elem=elem;
        cout<<"creating the left child node"<<endl;
        create_binary_tree(&((*root)->left));
        cout<<"creating the right child node"<<endl;
        create_binary_tree(&((*root)->right));
    }
}*/
//方法二
binary_tree create_binary_tree()
{
    int elem;
    binary_tree root;
    cout<<"Enter the node value (0 is end): ";
    cin>>elem;
    if(elem==0)
        root=NULL;
    else
    {
        //在堆空间分配的内存，可以返回局部对象
        root=(binary_tree)malloc(sizeof(binary_tree_node));
        if(root==NULL)
        {
            cout<<"malloc error"<<endl;
            exit(1);
        }
        (root)->elem=elem;
        cout<<"creating the left child node"<<endl;
        root->left=create_binary_tree();
        cout<<"creating the right child node"<<endl;
        root->right=create_binary_tree();
    }
    return root;
}

int main()
{
    binary_tree root;
    init_binary_tree(&root);
    root=create_binary_tree();
    cout<<"先序遍历：";
    preorder_traverse(root);
    cout<<endl;
    cout<<"中序遍历： ";
    inorder_traverse(root);
    cout<<endl;
    cout<<"后序遍历： ";
    postorder_traverse(root);
    cout<<endl;
    cout<<"层次遍历:  ";
    levelorder_traverse(root);
    cout<<endl;
    exit(0);
}
View Code

运行结果：

weixin_33743880
关注
数据结构：第十章_内部排序.ppt
09-17
3. **堆排序**：堆排序利用了数据结构——堆（一种特殊的完全二叉树）的特性。首先构建一个大顶堆或小顶堆，然后交换堆顶元素与末尾元素，将末尾元素移除，重复这个过程直到所有元素都有序。堆排序的平均和最坏情况...
算法 操作二叉查找树
sinat_33844073的博客
03-01 325
参考《数据结构与算法分析》 二叉查找树的建立： typedef struct binary_tree_ { int data; struct binary_tree_ *left; struct binary_tree_ *right; }binary_tree; //这里binary_tree = struct binary_tree_ 二叉查找树创建一个根节点：
二叉树的初始化
热门推荐
给永远比拿愉快
03-12 2万+
问题： 给定二叉树的初始化数据，怎样动态建立一个二叉树呢？ 比如我们给定这样的一组数据：{ 1, 2, 3, 4, 0, 5, 6, 0, 7 }（假设0代表空），则我们构建的二叉树是这样的: 1 / \ 2 3 / / \ 4 5 6 \ 7 思路分析： 我们可以使用一个队列，队首出一个元素，队未进两个元素，而这两个元素正
C语言 二叉树详解
e我所欲也的博客
02-07 4793
1.二叉树概念及结构 概念： 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。 特点： 1.二叉树是一种非线性的数据结构，每棵子树的根结点有且只有一个前驱节点（父亲节点） 2. 每个结点最多有两棵子树，即二叉树不存在度（度：一个节点含有的子树的个数称为该节点的度）大于2的结点。 3. 二叉树的子树有左右之分，其子树的次序不能颠倒。 4. ...
数据结构--二叉树--小小例题(完整注释）
hernofogot的博客
03-08 680
题目：二叉树的链式存储结构的建立、前序、中序、后序遍历的算法，查询“E”是否在二叉树。 #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; typedef char DataType; typedef struct Node { DataType data;/*数据域*/ struct Node *leftChild;/*左子树...
Binary_Tree
weixin_34302798的博客
11-28 80
#include<bits/stdc++.h> usingnamespacestd; typedeflonglongll; typedefunsignedlonglongull; #defineStatusint #defineSTACK_INIT_SIZE100 #defineSTACKINCREMENT10 #defineOK...
数据结构——C语言描述 第二版
03-15
《数据结构——C语言描述（第二版）》是王路群教授编著的一本深入讲解数据结构的教材，特别强调了使用C语言实现各种数据结构的方法。这本书涵盖了数据结构的基础理论与实践应用，旨在帮助读者理解和掌握数据结构的...
【数据结构ppt】 第十章+排序.ppt
09-19
堆排序利用了数据结构——堆的特性。堆是一个近似完全二叉树的结构，并同时满足堆的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。堆排序包括建堆、调整堆和提取最大元素（或最小元素）的过程，重复...
数据结构与算法课程总结
03-04
第七章“二叉树及其应用”讲解了非线性结构——二叉树。二叉树的建立、遍历、线索化和表达式求值等算法是学习内容，哈夫曼编码、平衡二叉排序树和堆排序是应用实例，平衡二叉排序树的实现是难点。 第八章“树和森林...
算法导论C语言实现: 二叉搜索树(binary tree)
v2nero的专栏
01-05 1867
1. 源代码 ia_binarytree.h #ifndef __IA_BINARY_TREE_H__ #define __IA_BINARY_TREE_H__ #include typedef struct _binary_tree_node_t { int key; struct _binary_tree_node_t *p; struct _binary_tree_nod
HJ51输出单向链表中倒数第k个结点
晴山の博客
10-29 300
HJ51输出单向链表中倒数第k个结点。
从零开始的LeetCode刷题日记：35. 分发糖果
chenjialehhh的博客
10-26 154
这道题的核心思想是分而治之！如果一开始就想着同时考虑一个小朋友的两边，那么很容易顾此失彼。我们可以先从前往后来确保这个方向的糖果数是符合题意的，然后再从后往前比较一次来确保另一个方向也符合题意，最后二者取最大值就同时满足了两边的需求。这里要注意的是，从前往后遍历的时候，比较的是i+1是否大于i，因为这有这样才能用到前面遍历得到的结果，逐步累加。同理，从后往前遍历比较的是i-1是否大于i。
【LeetCode】每日一题 2024_10_29 生成不含相邻零的二进制字符串（DFS）
Locky136的博客
10-29 303
【LeetCode】每日一题 2024_10_29 生成不含相邻零的二进制字符串（DFS）
echarts 遍历多个图表，并添加resize缩放
licongmingli的博客
10-30 214
遍历echarst多个图表，并添加独立的缩放函数
【深搜算法】（第四篇）
weixin_73861555的博客
10-27 1290
然⽽，通过观察我们可以发现，如果我们先删除最底部的叶⼦节点，然后再处理删除后的节点，最终的结果并不会受到影响。因此，在处理完⼦节点后，我们仍然需要处理当前节点。3. 函数作⽤：整合⽗节点的信息与当前节点的信息计算当前节点数字，并向下传递，在回溯时返回当前⼦树（当前节点作为⼦树根节点）数字和。前序遍历按照根节点、左⼦树、右⼦树的顺序遍历⼆叉树的所有节点，通常⽤于⼦节点的状态依赖于⽗节点状态的题⽬。后序遍历按照左⼦树、右⼦树、根节点的顺序遍历⼆叉树的所有节点，通常⽤于⽗节点的状态依赖于⼦节点状态的题⽬。
【动态规划】力扣198.打家劫舍
J_pluto的博客
10-27 392
题目中指出不可以选相邻的房间，说明如果选了第 1 间，那么第 2 间一定不可以选，第 3 间房间可以选，也可以不选……假设是按照从第 1 间房间开始依次往后选，每一间房间的选择都会影响到后面的房间可不可以被选择。在递归的基础上，创建一个数组 dp[] 来存储之前计算过的结果，避免重复计算。但这样提交会发现超时。
算法练习：四数之和
2302_80652761的博客
10-28 325
四数之和
【LeetCode】每日一题 2024_10_27 冗余连接（并查集）
Locky136的博客
10-27 336
【LeetCode】每日一题 2024_10_27 冗余连接（并查集）
线程安全的集合类
最新发布
zrwcnm的博客
10-31 241
如果修改同一个链表上的两个元素，可能就有线程安全问题，比如把这俩元素插入同一元素后面就可能产生竞争。效率更高，按照桶级别进行加锁，而不是给整个哈希加一个全局锁，有效降低锁冲突的概率。如果修改的两个元素，在不同链表上，本身就不涉及线程安全问题（修改不同变量）服务器代码中的其他逻辑就会读取这些数组/哈希中的值，不会修改。确保读取过程中，要么读到的是旧版数据，要么读到的是新版数据。把旧哈希中的所有元素搬运到新的哈希中（元素很多，耗时很长）服务器就会创建新的数组/哈希，加载新的配置。
并查集与高级数据结构——二叉树、线段树、树状数组
二叉树是计算机科学中的基本数据结构，包含二叉搜索树、Treap树和伸展树（Splay Tree）等变种。二叉搜索树保证左子树的所有元素小于根节点，右子树的所有元素大于根节点，这使得搜索、插入和删除操作的效率较高。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值