【2】二叉树基本题型整理

最新推荐文章于 2024-08-29 16:57:08 发布
最新推荐文章于 2024-08-29 16:57:08 发布
阅读量159 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33934427/article/details/104883549
版权

二、树（二叉树）

文章目录

1、备注：
  • 树的逻辑结构大致可以分为三种：双亲表示法，孩子表示法，孩子兄弟表示法
  • 树以遍历操作为主，一定要弄清楚非递归的先序，中序，后序和层次遍历算法，明白自定义栈或队列如何操作节点元素，方便应对许多题型.main函数如下，栈与队列的节点和函数定义详见【线性表】篇
int main()
{
    TNode *root = (TNode *)malloc(sizeof(TNode));
    root->data = 1;
    TNode *node2 = (TNode *)malloc(sizeof(TNode));
    node2->data = 2;
    TNode *node3 = (TNode *)malloc(sizeof(TNode));
    node3->data = 3;
    TNode *node4 = (TNode *)malloc(sizeof(TNode));
    node4->data = 4;
    TNode *node5 = (TNode *)malloc(sizeof(TNode));
    node5->data = 5;
    TNode *node6 = (TNode *)malloc(sizeof(TNode));
    node6->data = 6;
    TNode *node7 = (TNode *)malloc(sizeof(TNode));
    node7->data = 7;
    TNode *node8 = (TNode *)malloc(sizeof(TNode));
    node8->data = 8;
    TNode *node9 = (TNode *)malloc(sizeof(TNode));
    node9->data = 9;
    TNode *node10 = (TNode *)malloc(sizeof(TNode));
    node10->data = 10;

    root->lchild = node2;
    root->rchild = node3;
    node2->lchild = node4;
    node2->rchild = node5;
    node3->lchild = node6;
    node3->rchild = node7;
    node4->lchild = NULL;
    node4->rchild = node10;
    node5->lchild = node8;
    node5->rchild = NULL;
    node6->lchild = NULL;
    node6->rchild = NULL;
    node7->lchild = NULL;
    node7->rchild = NULL;
    node8->lchild = node9;
    node8->rchild = NULL;
    node9->lchild = NULL;
    node9->rchild = NULL;
    node10->lchild = NULL;
    node10->rchild = NULL;

    //levelOrder
    levelOrder(root);

    //preOrder
    preOrder_No_Recur(root);

    //inOrder
    inOrder_No_Recur1(root);

    //postOrder
    // postOrder_No_Recur(root);

    //postOrder1
    postOrder_No_Recur1(root);
}
2、先序遍历
Ⅰ、Demo 1：非递归先序

算法思想：

  • 先将根结点压入栈，取出根结点。
    undefined把右孩子压入栈，再把左孩子压入栈
void preOrder_No_Recur(TNode *root)
{
    Stack stack;
    InitStack(&stack);
    push(&stack, root);
    printf("preOrder: ");
    while (!isStackEmpty(&stack))
    {
        TNode *node = pop(&stack);

        printf("%d ", node->data);
        //先压入右孩子，再压左孩子
        if (node->rchild != NULL)
        {
            push(&stack, node->rchild);
        }
        if (node->lchild != NULL)
        {
            push(&stack, node->lchild);
        }
    }
    printf("\n");
}
3、中序遍历
Ⅰ、Demo 1：非递归中序

算法思想：

  • 将左孩子一次性压入栈，
  • 取出栈顶结点，先打印，再压入右孩子。
  • 如果右孩子有左孩子，取出栈顶结点，再次把其左孩子一次性压入
  • 如果无，则将指针置为NULL,不用左压
void inOrder_No_Recur1(TNode *root)
{
    Stack stack;
    InitStack(&stack);
    printf("inOrder1: ");
    TNode *p = root;
    while (p != NULL || !isStackEmpty(&stack))
    {

        if (p != NULL)
        {
            push(&stack, p);
            p = p->lchild;
        }
        else
        {
            p = pop(&stack);
            printf("%d ", p->data);
            if(p->rchild != NULL){
                p = p->rchild;
                push(&stack,p);
                p = p->lchild;
            }
            else{
               p = NULL;
            }
        }        
    }
    printf("\n");
}
4、后序遍历
Ⅰ、Demo 1：非递归后序

算法思想（较难，好好理解）：

1）双栈法

  • 一个节点栈，一个标记栈，标记子树中的根节点是否被访问两次

  • 先一次性压入左孩子，peek一下栈顶，

  • 如果sign为false，将sign相应位置为True，再访问右孩子
  • 如果sign为true,表示已经访问过右孩子，无需继续访问，直接输出
  • 取出栈顶结点，先打印，再压入右孩子。
  • 如果右孩子有左孩子，取出栈顶结点，再次把其左孩子一次性压入
  • 【注】:如何保证根节点标记为true后，不会连续压入右孩子???
void postOrder_No_Recur(TNode *root)
{
    PostStack postStack;
    InitPostStack(&postStack);
    TNode *node = root;
    bool flag = false;
    printf("postOrder: ");
    while (node != NULL || !isPostStackEmpty(&postStack))
    {
        //如果flag为false，为第一次访问该节点，一次性压入左孩子
        while (flag == false && node != NULL)
        {
            pushPostStack(&postStack, node);
            pushPostStackSign(&postStack, false);
            node = node->lchild;
        }

        node = peekPostStack(&postStack);
        flag = peekPostStackSign(&postStack);

        //先将根标记true，表示第二次查询，再访问右孩子
        if (!flag)
        {
            flag = true;
            popPostStackSign(&postStack);
            pushPostStackSign(&postStack, flag);
            if (node->rchild != NULL)
            {
                node = node->rchild;
                //将右孩子标记为未被访问
                flag = false;
            }
        }
        else
        {
            node = popPostStack(&postStack);
            printf("%d ", node->data);
            node = node->rchild;
            popPostStackSign(&postStack);
        }
    }
    printf("\n");
}

postStack代码

//后序遍历用的栈
typedef struct PostStack
{
    ElemType *data[maxsize]; //指针数组
    bool sign[maxsize];
    int top1;
    int top2;
} PostStack;

void pushPostStackSign(PostStack *stack, bool flag)
{
    stack->sign[++stack->top2] = flag;
}

bool popPostStackSign(PostStack *stack)
{
    return stack->sign[stack->top2--];
}

bool peekPostStackSign(PostStack *stack)
{
    return stack->sign[stack->top2];
}
2）单栈法
  • 用r来表示最近访问的节点
  • 主要判断是否有右孩子，并根据r判断右孩子是否访问过
void postOrder_No_Recur1(TNode *root){

    Stack stack;
    InitStack(&stack);
    // push(&stack,root);  //（概念上的）根节点在p非空，依次压入左孩子时压入栈，不在初始时压入根结点
    TNode *r = NULL;  //r的初值为NULL
                      //表示最近一次访问的结点（若r为左结点，则右结点未访问，需访问，然后将r置为右结点）
    TNode *p = root;
    printf("postOrder1: ");
    while(p != NULL || !isStackEmpty(&stack)){//若栈空，遍历指针p也为空，则遍历结束
         if(p != NULL){  //若p非空
             push(&stack,p);
             p = p->lchild;
         }

         else  //p为空，则左孩子压入完毕，先取出当前p的根节点，即栈顶元素
         {
            p = peek(&stack);
            if(p -> rchild != NULL && p -> rchild != r)//若右孩子非空且右孩子未被访问
            {
                p = p -> rchild;
                push(&stack,p);//先将右孩子压入栈
                p = p -> lchild;  //将指针指向左结点，进入下一次循环，一次性压入左结点
            }
            else{   //若右孩子被访问过，则弹出栈顶元素,即为右孩子，并将右孩子标识访问过
                    //若无右孩子，则弹出栈顶元素,即为根结点
                p = pop(&stack);
                printf("%d ",p->data);
                r = p;
                p = NULL;    //由于这里是打印“右孩子”，下一步需要打印其根节点，
                             //即为出栈操作，须将p置null，避免继续压入左孩子。
            }
         }
    }
    printf("\n");
}
Ⅱ、Demo 2：x的祖先

1）描述：

  • 在二叉树中查找值为x的结点，编写算法打印值为x的结点的所有祖先，假设值为x的结点不多于一个

2）算法思想：

  • 采用非递归的后序遍历，当压入的结点为需要打印的x结点时，即栈内元素，即为结点x的所有祖先
void getAncestors(TNode *root,int x){

    Stack stack;
    InitStack(&stack);
   
    TNode *r = NULL;       
    TNode *p = root;
    printf("postOrder1: ");
    while(p != NULL || !isStackEmpty(&stack)){//若栈空，遍历指针p也为空，则遍历结束
         if(p != NULL){  //若p非空
             push(&stack,p);
             p = p->lchild;
         }

         else  //p为空，则左孩子压入完毕，先取出当前p的根节点，即栈顶元素
         {
            p = peek(&stack);
            if(p -> rchild != NULL && p -> rchild != r)//若右孩子非空且右孩子未被访问
            {
                p = p -> rchild;
                push(&stack,p);//先将右孩子压入栈
                p = p -> lchild;  //将指针指向左结点，进入下一次循环，一次性压入左结点
            }
            else{  
                p = pop(&stack);
                if(p -> data == x){
                    break;
                }
                else
                {
                   r = p;
                   p = NULL;       
                }
            }
         }
    }

    while (!isStackEmpty(&stack))
    {
        printf("%d ",pop(&stack) -> data);
    }
    
    printf("\n");
}
5、层次遍历
Ⅰ、Demo 1：非递归层次

算法思想：

  • 先将根结点压入队列，取出根结点。
  • 把左孩子压入队列，再把右孩子压入队列
void levelOrder(TNode *root)
{
    Queue queue;
    InitQueue(&queue);
    Enqueue(&queue, root);
    printf("levelOrder: ");
    while (!isQueueEmpty(&queue))
    {
        TNode *node = Dequeue(&queue);

        printf("%d ", node->data);
        //先压入左孩子，再压右孩子
        if (node->lchild != NULL)
        {
            Enqueue(&queue, node->lchild);
        }
        if (node->rchild != NULL)
        {
            Enqueue(&queue, node->rchild);
        }
    }
    printf("\n");
}
Ⅱ、Demo 2：逆层次遍历

1）描述：

  • 试给出二叉树的自下而上，从右到左的层次遍历算法

2）算法思想：

  • 采用层次遍历的非递归算法，不同的是右孩子先进入队列，左孩子再进入队列
void levelOrder(TNode *root)
{
    Queue queue;
    InitQueue(&queue);
    Enqueue(&queue, root);
    printf("levelOrder: ");
    while (!isQueueEmpty(&queue))
    {
        TNode *node = Dequeue(&queue);

        printf("%d ", node->data);
        //先压入左孩子，再压右孩子
        if (node->lchild != NULL)
        {
            Enqueue(&queue, node->lchild);
        }
        if (node->rchild != NULL)
        {
            Enqueue(&queue, node->rchild);
        }
    }
    printf("\n");
}
Ⅲ、Demo 3：树的高度

1）描述：

  • 假设二叉树采用二叉链表存储结构，设计一个非递归算法求二叉树的高度

2）算法思想：

  • 采用层次遍历的算法，设置变量level记录当前结点所在的层数，
  • 设置last指针指向当前层的最右的结点（last指针就好比操作链表的cur，pre指针，只不过赋予了不同的职责）
  • 每次层次遍历出队时与last指针比较，若两者相等，则层数+1（说明当前层及以上已经遍历完，更新一下level），
  • 并让last指向下一层的最右的结点，直到遍历完成。level即为二叉树的高度
  • 【注】:这里可以使用循环队列，但需增加一个getRear(), 也可以不使用循环队列

循环队列

void getLevel1(TNode *root){
    
    Queue queue;
    InitQueue(&queue);
    Enqueue(&queue,root);
    
    TNode *last = root;  //用来记录出队时最右的结点,再root出队后，初始时指向root
    int level = 0;
    while(!isQueueEmpty(&queue)){
        TNode *p  = Dequeue(&queue);
        
        if(p -> lchild != NULL){
            Enqueue(&queue,p -> lchild);
        }
        if(p -> rchild != NULL){//不能用else if
            Enqueue(&queue,p -> rchild);
        }

        if(last == p){
            level++;
            /**
             *     last指向下一层的最右结点,因为last和p相同，last为上一层最右的结点
             * 这时两种情况:p有孩子，p无孩子
             * p有孩子:压入队列的孩子即为下一层最右的结点
             * p无孩子:当前的队列的rear结点即为下一层最右的结点
             */
            last = getRear(&queue);
        }
    }

    printf("level : %d ",level);
}

非循环队列（可能会溢出）

void getLevel2(TNode *root){
 
     int front = -1, rear = -1;
     TNode *queue[maxsize]; //二叉链表的指针数组
     queue[++rear] = root;
     
     TNode *last = root;
     int level = 0;
     while(front != rear){
        TNode *p = queue[++front];

        if(p -> lchild != NULL){
            queue[++rear] = p -> lchild;
        }
        if(p -> rchild != NULL){//不能用else if
            queue[++rear] = p -> rchild;
        }
 
        if(last == p){
            level++;
            last = queue[rear];
        }
     }
    printf("level1 : %d ",level);
}
Ⅳ、Demo 4：判断完全二叉树

1）描述：

  • 二叉树按二叉链表形式存储，写一个判别给定二叉树是否是完全二叉树的算法

2）算法思想：

  • 采用层次遍历的算法，将所有的结点加入队列（包括空结点），出队遇到空结点时

查看其后是否有非空结点，若有，则二叉树不是完全二叉树。

int isComplete(TNode *root){
    
    Queue queue;
    InitQueue(&queue);
    Enqueue(&queue,root);
    
    while(!isQueueEmpty(&queue)){
        TNode *p  = Dequeue(&queue);
        
        //空结点也入队列
        if(p != NULL){
            Enqueue(&queue,p -> lchild);
            Enqueue(&queue,p -> rchild);
        }
    
        else
        {
            while(!isQueueEmpty(&queue)){
                p = Dequeue(&queue);
                //若空结点后还有非空结点，则非完全二叉树
                if(p != NULL){
  
                    printf("isn't a complete tree\n");
                    return 0;
                }
            }
        }
    }
    printf("is a complete tree\n");
    return 1;
}
Ⅴ、Demo 5：左右子树交换

1）描述：

  • 设树B是一棵采用链式结构存储的二叉树，编写一个把树B中所有结点的左右子树进行交换的函数

2）算法思想：

  • 采用层次遍历的算法，设置一个temp指针，用它的右指针指向当前非空结点cur的右结点，

    待cur的右指针指向左孩子后，cur的左指针指向temp的右孩子。

void swap(TNode *root){

    Queue queue;
    InitQueue(&queue);
    Enqueue(&queue,root);

    TNode *temp = (TNode *) malloc(sizeof(TNode));
    while(!isQueueEmpty(&queue))
    {
        TNode *p = Dequeue(&queue);
        
        temp -> rchild = p -> rchild;
        p->rchild = p -> lchild;
        p->lchild = temp -> rchild;

        //不要忘了层次遍历的主体部分
        if(p -> lchild != NULL){
            Enqueue(&queue,p -> lchild);
        }
        if(p -> rchild != NULL){//不能用else if
            Enqueue(&queue,p -> rchild);
        }

        temp -> rchild = NULL;
    }
}
王小希ww
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树常见问题整理
yy254117440的博客
11-22 4660
做leetcode二叉树的题目做了不少，觉得有必要总结一下。因为题型多归多，但其实无非就是dfs和bfs，总结一些常见的解法，对于加深这两周算法的理解很有帮助。 在做dfs的时候，主要思路是可以从上到下也可以从下到上，也就是分析每一个子树的根节点，然后分析该子树的内部子树或者外部子树的根节点，以此得出递归关系，也即是分治的思想。同时，对于每个节点的处理尝试利用前序、后序、中序遍历三种方法。 做b
java二叉树算法面试题大全含答案，月薪20k+的Java面试都问些什么
2401_84413631的博客
04-23 947
21二叉树算法刷题LeetCode中文版：二叉树。
二叉树题型
！
12-24 313
目录二叉数遍历迭代法1.1前序遍历题目描述1.2中序遍历1.3后续遍历二叉树最小深度二叉树所有路径中序后序构造二叉树验证二叉搜素树前序遍历顺序：根—左—右；解法1：用栈来进行中间过程处理，结果存入vector中思路：每次先处理中间的结点，先将根结点入栈，再将右孩子入栈，左孩子入栈。每次从栈顶拿数据，重复操作。 代码演示： 解法2：中序遍历是先访问根结点，然后访问左子树。我们可以直接把先访问的根结点直接存入vector中，然后去遍历它的左子树。重复上一次操作。当它的左子树为空时，则去遍历它的右子树。（右
二叉树题型汇总
weixin_43693143的博客
03-14 209
树easy1.实现二叉树的先序、中序、后序遍历2.二叉树的层序遍历3.求二叉树的深度4.二叉搜索树的第k个节点 easy 1.实现二叉树的先序、中序、后序遍历 题目描述： 分别按照二叉树先序，中序和后序打印所有的节点。 输入：{1,2,3} 返回：[[1,2,3],[2,1,3],[2,3,1]] 思路： 建立返回vector，vector的0号元素放在左右子树遍历之前，vector1号元素放在左右子树遍历之间，vector2号元素放在左右子树遍历之后 代码： class Solution { pu
二叉树的各种题型详解
qq_43842119的博客
12-08 430
根据先序和中序求后序遍历 后续遍历就是先遍历左子树，然后是右子树，最后是根 由先序和中序，可以知道根和左右子树的位置，对其按照后续遍历的规则遍历即可 每次用k++，就可以获取先序的根节点，对于先序来说，其实一直都是根节点 获取rt后，对中序切割，便可以得到左子树和右子树，对左右子树继续遍历 当 rt=f 时，说明没有左子树，当 rt =r 时，说明没有右子树，输出此节点即可 rt&l...
二叉树基本题型总结
LiAphrodite的博客
08-27 208
二叉树 前序|中序|后序遍历 前序：跟+左子树的前序（递归）+右子树的前序（递归） 中序：左子树的中序（递归）+跟+右子树的中序（递归） 后序：左子树后序（递归）+右子树的后序（递归）+跟 递归方法的一些诀窍： 1.不要写方法的就做递归展开，站在自己的角度思考，先不用管其他结点 2.找终止条件，在变化的因素中确定，也就是形参 3.找向下的递推公式 4.理解递归方法的调用过程中，会被调用很多次...
二叉树所有题目（数据结构与算法）
逆流而上Mr李
07-04 2883
最近总结了一些数据结构和算法相关的题目，这是第一篇文章，关于二叉树的。 先上二叉树的数据结构： class TreeNode{ int val=0; //左孩子 TreeNode left=null; //右孩子 TreeNode right=null; public TreeNode(int val) { this.val = val...
最值得收藏的 数据结构 全部知识点思维导图整理(王道考研), 附带经典题型整理.emmx.zip
10-08
经典题型整理部分可能会涵盖实际编程题目，比如实现某种数据结构的操作，或是对已知算法进行改进。考生需要熟练运用所学知识，解决实际问题。 总之，这个资源集成了数据结构的重要知识点和经典题型，对于准备考研的...
动态规划-各种题型及思路整理（自用笔记，大神绕道）_动态规划题型
2401_84254364的博客
05-02 152
动态规划(dynamic programming，简称dp)，是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。（没办法，其实算法就是数学，毕竟数学是基础学科，由数学支撑的学科太多太多）
leetcode二叉树面试题目集锦
xiangxianghehe的博客
08-18 6935
struct BinaryTreeNode { int value; BinaryTreeNode* left; BinaryTreeNode* right; BinaryTreeNode(int x) : value(x), left(NULL), right(NULL) {} }; 初始化 BinaryTreeNode *root = new ...
二叉树的几道典型例题
chenkaixin_1024的博客
05-02 3132
1.求二叉树的高度 int _GetTreeHight(Node* pRoot) { if(pRoot==NULL) return 0; if(pRoot->_pLeft==NULL&&pRoot->_pRight==NULL) return 1; int left=_GetTreeHight(pRoot->_pLeft)+1; int right=_GetTr
二叉树的各种常见题型
齐梦星空
03-11 218
前序遍历 def pre_search(root: TreeNode): res = [] if root is None: return res stack = [root] # 使用的是栈 while stack: p = stack.pop() res.append(p.val) if p....
关于二叉树的常见题型
丹妮专栏
07-16 2987
一、二叉树相关概念 1.1 基本术语 结点的度：一个结点的子结点的个数称为结点的度。树的度：树中结点的最大度数为树的度树的深度（高度）：树中结点的最大层数，从1开始。 1.2 二叉树分类 满二叉树：一颗高度为h，并且含有2^h-1个结点的二叉树称为满二叉树。即树中每一层都含有最多的节点。除叶子节点每个节点的度都为2。 完全二叉树：当高度为h，具有n个结点的二叉树，
Leetcode42接雨水（单调栈）
AGNING的博客
08-28 430
维护一个栈，满足从栈底到栈顶元素大小递减。如果当前元素高于栈顶，且栈内有至少2个元素，则形成了一个凹槽，及一个图中横着的红色矩形，将它的面积累加即可，第一次写难在维护单调栈中计算面积和。求出前缀最大和后缀最大，用两者较小值减去当前高度，累加即可，这个思路容易想到，这里不赘述。
算法的学习笔记—连续子数组的最大和
最新发布
业精于勤，荒于嬉
08-29 3413
通过上述的动态规划方法，我们能够有效地解决连续子数组的最大和问题。该方法简单易懂，并且具有较高的效率，适合在大多数情况下使用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😁如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🤞。
递归、搜索与回溯算法
无聊_人的博客
08-29 6287
所谓的递归其实就是函数自己调用自己的情况。
代码随想录算法训练营第62天|Floyd 算法精讲、A * 算法精讲 （A star算法）
Yinems的博客
08-28 1306
分两种情况，一种是节点 i 到节点 j 的最短路径经过节点 k，grid[i][j][k] = grid[i][k][k-1] + grid[k][j][k-1]；另一种情况，节点 i 到节点 j 的最短路径不经过节点 k，grid[i][j][k] = grip[i][j][k-1]；刚开始初始化 k 是不确定的，如果赋值为1，那么不能知道节点 i 到节点 j 经过1个节点的最短距离，所以只能把 k 赋值为0，本题中节点0是无意义的，节点是从1到n。本题求的是最小值，所以其余值初始化为最大值。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 4549
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
完全二叉树与二叉树基本概念详解
完全二叉树是二叉树的一种特殊形态，它在数据结构中有着重要的应用。在计算机科学中，特别是树和二叉树的相关理论中，完全二叉树具有一些独特的性质和特点。 首先，定义一个完全二叉树时，它是指一棵二叉树，其中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值