数据结构之王道二叉树大题

最新推荐文章于 2023-09-05 16:58:19 发布
最新推荐文章于 2023-09-05 16:58:19 发布
阅读量308 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43906877/article/details/117367393
版权

notes:
1.global存了一些结构体,定义见后边
2.使用了队列，队列的操作的实现，见其他文章
3.使用了数学库，编译命令类似于 gcc -g tree.c -o tree -lm

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//global存了一些结构体
#include "Global.h"
//使用了队列
#include "LinkQueue.c"
//使用了数学库，编译命令类似于 gcc -g tree.c -o tree -lm
#include <math.h>
Tree InitTree(int data)
{
    Tree head= (Tree)malloc(sizeof(TreeNode));
    head->data=data;
    head->lchild=NULL;
    head->rchild=NULL;
    return head;
}
Tree LeftInsertTree(Tree head,int data)
{
    Tree temp=malloc(sizeof(TreeNode));
    if (temp==NULL) return NULL;
    temp->data=data;
    temp->lchild=NULL;
    temp->rchild=NULL;
    head->lchild=temp;
    return temp;
}
Tree RightInsertTree(Tree head,int data)
{
    Tree temp=malloc(sizeof(TreeNode));
    if (temp==NULL) return NULL;
    temp->data=data;
    temp->lchild=NULL;
    temp->rchild=NULL;
    head->rchild=temp;
    return temp;
}
int InsertLeftAndRight(Tree head,Tree left,Tree right,int ldata,int rdata)
{
    Tree lt=malloc(sizeof(TreeNode));
    Tree rt=malloc(sizeof(TreeNode));
    if(lt==NULL||rt==NULL) return -1;
    lt->data=ldata;
    lt->lchild=NULL;
    lt->rchild=NULL;
    rt->data=rdata;
    rt->lchild=NULL;
    rt->rchild=NULL;
    head->lchild=lt;
    head->rchild=rt;
    left=lt;
    right=rt;
    return 1;
}
void Visit(Tree head)
{
    
    printf(" %c ",head->data);
}
void PreOrder(Tree head)
{
    if(head!=NULL)
    {
        Visit(head);
        PreOrder(head->lchild);
        PreOrder(head->rchild);
    }
}
void InOrder(Tree head)
{
    if (head!=NULL)
    {
        InOrder(head->lchild);
        Visit(head);
        InOrder(head->rchild);
    }
    
}

void LevelOrder(Tree root)
{
    LinkQueue queue;
    Tree p;
    InitLinkQueue(&queue);
    EnQueue(&queue,root);
    while(!IsEmpty(&queue))
    {
        DeQueue(&queue,&p);
        Visit(p);
        if (p->lchild!=NULL)
        {
            EnQueue(&queue,p->lchild);
        }
        if (p->rchild!=NULL)
        {
            EnQueue(&queue,p->rchild);
        }
    }

}

int GetTreeHight(Tree root)
{
    if(root==NULL) return 0;
    int front=-1,rear=-1;
    int last=0,level=0;
    Tree Q[MaxSize];
    Q[++rear]=root;
    Tree p;
    //队列非空
    while(front<rear)
    {
        p=Q[++front];
        if (p->lchild!=NULL)
        {
            Q[++rear]=p->lchild;
        }
        if (p->rchild!=NULL)
        {
            Q[++rear]=p->rchild;
        }
        //到了一层的层尾
        if (front==last)
        {
            level++;
            //此时下一层已经全部如队，此层已经全部出对
            last=rear;
        }
    }
    return level;
}

int GetTreeWight(Tree root)
{
    if (root==NULL)
    {
        return 0;
    }
    Tree Q[MaxSize];
    int rear=-1,front=-1;
    int level=0,last=0;
    int count=0;
    Tree p;
    //注意越界，但是我不会写动态分配的代码，emmm
    int wights[10]={0,0};
    Q[++rear]=root;
    while(front<rear)
    {
        p=Q[++front];
        count++;
        if (p->lchild!=NULL)
        {
            Q[++rear]=p->lchild;
        }
        if (p->rchild!=NULL)
        {
            Q[++rear]=p->rchild;
        }
        if (last==front)
        {
            wights[level]=count;
            count=0;
            level++;
            last=rear;
        }
    }
    int i=0,max=0;
    for (int i = 0; i < 10; i++)
    {
        if (wights[i]>max) max=wights[i];
    }
    return max;
}


//根据先序遍历序列和中序遍历序列建立一个二叉树
//先序：ABCDEFGHI
//中序：BCAEDGHFI
//l1 0 l2=8 l2 0 h2 8
//i=2  h2-i=6 l2=2
Tree PreInCreat(char PreQueen[],char InQueen[],int l1,int h1,int l2,int h2)
{
    //l1 l2指向先序和中序的第一个元素
    //h1 h2指向先序和中序的最后一个元素
   //首先根据先序序列找到根节点
    Tree root=InitTree(PreQueen[l1]);
    //根据中序序列找到左子数的元素，和右子树的元素
    int i=0,llen=0,rlen=0;
    for (i = l2; root->data!=InQueen[i]; i++);
    llen=i-l2;
    rlen=h2-i;
    //注意，在递归建立时注意不要改变值，也就是如果表达i往后移动一位，不能是i++而是i+1
    //尽量不使用i表达
    if (llen!=0)
        root->lchild=PreInCreat(PreQueen,InQueen,l1+1,l1+llen,l2,l2+llen-1);
    else
        root->lchild=NULL;
    if (rlen!=0)
        root->rchild=PreInCreat(PreQueen,InQueen,h1-rlen+1,h1,h2-rlen+1,h2);
    else
        root->rchild=NULL;
    return root;
}

//利用层次遍历的思想 判断是不是完全二叉树 垃圾版
//贼垃圾，不要看
int Low_IsFullTree(Tree root)
{
    if (root==NULL) return -1;
    int last=0,level=0;
    int count=0;
    int front=-1,rear=-1;
    int heigth=GetTreeHight(root);
    Tree Q[MaxSize];
    Tree p;
    //入队
    Q[++rear]=root;
    while (front<rear)
    {
        //出队
        p=Q[++front];
        //每次如队列一个就加一可以统计每层的个数
        count++;
        if (p->lchild!=NULL)
        {
            Q[++rear]=p->lchild;
        }
        if (p->rchild!=NULL)
        {
            Q[++rear]=p->rchild;
        }
        //如果队列的前指针指向了last
        //说明这一层遍历完了
        if (last==front&&level!=heigth-2)
        {
            level++;
            //刚遍历完时，rear指向这一层的尾节点
            last=rear;
            //看看这一层是不是满的
            //不是满的有两种情况，第一种不是完全二叉树
            //第二种，最后一层
            //如果不进if说明是满二叉树
            if (pow(2,level-1)!=count)
            {
                return 0;
            }
            //这层完了，下一层重新计数
            count=0;
        }
        //刚进倒数第二层，遍历每一个节点
        if(level==heigth-2)
        {
            int flag_1=1,flag_2=0;
            int t_front=front,t_rear=rear;
            int i=0;
            while(t_front-t_rear!=1)
            {
                if (Q[t_front]->lchild==NULL || Q[t_front]->rchild==NULL)
                {
                   if (flag_1==1) flag_2++;
                }
                else
                {
                    if(flag_1==0) flag_2++;
                }
                if(flag_2==2||flag_2>2) return 0; 
                t_front++;
            }
        }
    }
    return 1;
}

//升级版 是不是完全二叉树
int IsFullTree_Pro(Tree root)
{
    int front=-1,rear=-1;
    Tree Q[MaxSize];
    Q[++rear]=root;
    Tree p;
    while(front==rear)
    {
        p=Q[++front];
        if (p!=NULL)
        {
            Q[++rear]=p->lchild;
            Q[++rear]=p->rchild;
        }
        else
        {
            Q[++rear]=NULL;
        }
    }
    int i=0;
    while(i!=rear)
    {
        if (Q[i]==NULL)
        {
            int j=i+1;
            while(j!=rear)
            {
                if (Q[j]!=NULL)
                {
                    return 0;
                }
            }
        }
        i++;
    }

}

//计算所以双分支节点个数，层次遍历写法
int DoubelChildCount(Tree root)
{
    if (root==NULL) return 0;
    LinkQueue *queue;
    InitLinkQueue(queue);
    EnQueue(queue,root);
    Tree p;
    int count=0;
    while(!IsEmpty(queue))
    {
        DeQueue(queue,p);
        if (p->lchild!=NULL&&p->rchild!=NULL)
        {
            count++;
        }
        if (p->lchild!=NULL)
        {
            EnQueue(queue,p->lchild);
        }
        if (p->rchild!=NULL)
        {
            EnQueue(queue,p->rchild);
        }
    }
}

//递归写法，计算所有双分支节点的个数
int DoubelChildCount_digui(Tree root)
{
    if (root==NULL)
    {
        return 0;
    }
    else if (root->lchild!=NULL&&root->rchild!=NULL)
    {
        return DoubelChildCount_digui(root->lchild)+DoubelChildCount_digui(root->rchild)+1;
    }
    else
    {
        return DoubelChildCount_digui(root->lchild)+DoubelChildCount_digui(root->rchild);
    }  
}

//层次遍历交换左右节点
int ChangeLeftAndRight(Tree root)
{
    if (root==NULL) return 0;
    LinkQueue *queue;
    InitLinkQueue(queue);
    EnQueue(queue,root);
    Tree p,temp;
    int count=0;
    while(!IsEmpty(queue))
    {
        DeQueue(queue,p);
        //交换节点
        temp=p->rchild;
        p->rchild=p->lchild;
        p->lchild=temp;
        //此时左右分支还没有进入队列
        if (p->lchild!=NULL)
        {
            EnQueue(queue,p->lchild);
        }
        if (p->rchild!=NULL)
        {
            EnQueue(queue,p->rchild);
        }
    }
}
//递归交换左右节点
void ChangeLeftAndRight_digui(Tree root)
{
    if (root==NULL)
    {
        return ;
    }
    else
    {
        Tree temp;
        temp=root->lchild;
        root->lchild=root->rchild;
        root->rchild=temp;
        ChangeLeftAndRight_digui(root->lchild);
        ChangeLeftAndRight_digui(root->rchild);
    }
    
}
//根据根节点删除一棵树
void Delete(Tree root)
{
    if (root!=NULL)
    {
        Delete(root->lchild);
        Delete(root->rchild);
        //左右节点都被删除完了，此节点必然左右为空
        free(root);
    }
    return ;
}
//删除节点是x的的节点，并删除以x为根节点的树
void DeleteX(Tree root,char x)
{
    if (root!=NULL)
    {
        //检查该节点是不是x
        if (root->data==x)
        {
            Delete(root);
        }
        //递归访问左右节点
        DeleteX(root->lchild,x);
        DeleteX(root->rchild,x);
    } 
    return ;
}
//打印值为x的节点的所有祖先
int PrintXParents(Tree root,char x)
{
    if (root!=NULL)
    {
        if (root->data==x)
        {
            printf(" %c",root->data);
            return 1;
        }
        int flag_1= PrintXParents(root->lchild,x);
        if (flag_1==1)
        {
            printf(" %c",root->data);
            return 1;
        }
        int flag_2= PrintXParents(root->rchild,x);
        if (flag_2==1)
        {
            printf(" %c",root->data);
            return 1;
        }
    }
    return 0;
}


//根据先序建立满二叉树，递归吧，递归好写阿红红火火
Tree FullQueueCreatTree(char queue[],int begin,int end)
{
    //别着急，先检查以下序列，如果是满二叉树的序列应该个数上有限制
    int i=0,len=end-begin+1,child_len=(end-begin)/2;
    while(1)
    {
        //正好等比求和是他
        if ((pow(2,i)-1)==len) break;
        //i只会越来越大，不可能再次相等
        if (pow(2,i)>len) return NULL;
        i++;
    }
    Tree root=malloc(sizeof(TreeNode));
    //头节点已经建好，递归建立左右子树
    root->data=queue[begin];
    if (begin==end)
    {
        return root;
    }
    root->lchild=FullQueueCreatTree(queue,begin+1,begin+child_len);
    root->rchild=FullQueueCreatTree(queue,begin+child_len+1,end);
    return root;
}


int main()
{
    char PreQueen[]="ABCDEFGHI";
    char InQueen[]="BCAEDGHFI";
    printf("%s,%s",PreQueen,InQueen);
    Tree head=PreInCreat(PreQueen,InQueen,0,8,0,8);
    PreOrder(head);
    InOrder(head);
    LevelOrder(head);
    printf("%d\n",GetTreeHight(head));
    printf("-------find x parents--------\n");
    PrintXParents(head,'E');
    printf("\n-------get root wights--------\n");
    printf("%d\n",GetTreeWight(head));
    printf("\ncreat tree\n");
    Tree root=FullQueueCreatTree("ABDECFG",0,6);
    PreOrder(root);
}

//2014年 真题
// typedef struct WPL_Tree
// {
//     struct WPL_Tree *left,*right;
//     int weight;
// } *WTree;
// int PreOrderWPL(WTree root,int deep)
// {
//     int wpl=0;
//     if (root->right==NULL&&root->left==NULL)
//     {
//         return deep*root->weight;
//     }
//     if (root->left!=NULL)
//     {
//         wpl+=PreOrderWPL(root->left,deep+1);    
//     }
//     if (root->right!=NULL)
//     {
//         wpl+=PreOrderWPL(root->right,deep+1);
//     }
//     return wpl;
// }

//2017年真题
// typedef struct node
// {
//     char data[10];
//     struct node *left,*right;
// } BTree;
// char* GetExpress(BTree *root,int deep)
// {
//     char * ex=NULL;
//     if (root!=NULL)
//     {
//         char op=root->data;
//         if (deep==1)
//         {
//             char *a= GetExpress(root->left,deep+1);
//             char *b= GetExpress(root->right,deep+1);
//             ex=*a+op+*b;        
//         }
//         if (root->left==NULL&&root->right==NULL)
//         {
//             return root->data;
//         }
//         char *a= GetExpress(root->left,deep+1);
//         char *b= GetExpress(root->right,deep+1);
//         ex='('+*a+')'+op+'('+*b+')';
//     }
//     return ex;
// }


#ifndef __GLOBAL_H__
#define MaxSize 255
typedef struct TreeNode
{
    char data;
    struct TreeNode *lchild,*rchild;
} TreeNode,*Tree;
//数据类型定义
typedef struct LinkNode
{
    Tree data;
    struct LinkNode *next;    
} LinkNode;
typedef struct
{
    LinkNode *front,*rear;
} LinkQueue;
void InitLinkQueue(LinkQueue *queue);
void EnQueue(LinkQueue *queue,Tree data);
int DeQueue(LinkQueue *queue, Tree *data);

#define __GLOBAL_H__
#endif
邱敬宝
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树习题
01-16
（1）非递归定义 树（tree）是由n（n≥0）个结点组成的有限集合。n=0的树称为空树；n＞0的树T： ① 有且仅有一个结点n0，它没有前驱结点，只有后继结点。n0称作树的根（root）结点。 ② 除结点外n0 ， 其余的每一个结点都有且仅有一个直接前驱结点；有零个或多个直接后继结点。 （2）递归定义 一颗大树分成几个大的分枝，每个大分枝再分成几个小分枝，小分枝再分成更小的分枝，… ，每个分枝也都是一颗树，由此我们可以给出树的递归定义。 树（tree）是由n（n≥0）个结点组成的有限集合。n=0的树称为空树；n＞0的树T： ① 有且仅有一个结点n0，它没有前驱结点，只有后继结点。n0称作树的根（root）结点。 ② 除根结点之外的其他结点分为m（m≥0）个互不相交的集合T0，T1，…，Tm-1，其中每个集合Ti（0&le;i＜m）本身又是一棵树，称为根的子树（subtree）。 2、掌握树的各种术语： （1） 父母、孩子与兄弟结点 （2） 度 （3） 结点层次、树的高度 （4） 边、路径 （5） 无序树、有序树 （6） 森林 3、二叉树的定义 二叉树（binary tree）是由n（n≥0）个结点组成的有限集合，此集合或者为空，或者由一个根结点加上两棵分别称为左、右子树的，互不相交的二叉树组成。 二叉树可以为空集，因此根可以有空的左子树或者右子树，亦或者左、右子树皆为空。 4、掌握二叉树的五个性质 5、二叉树的二叉链表存储。
数据结构之王道链表大题
weixin_43906877的博客
05-22 283
#include<stdio.h> #include<stdlib.h> typedef struct Node{ int data; struct Node *next; }Node,*PNode; //tips: //PNode temp=node->next; 这样是个指针，指向某个节点，free(temp)是释放temp所指向节点的内容 //PNode temp = (PNode) malloc(sizeof(Node)); 这样是先向系统申请了个no
二叉树题目练习
博客
06-03 237
求一棵二叉树的最大高度 public static int getDepth(Node root){ if(root == null){ return 0; } int leftMax = getDepth(root.left); int rightMax = getDepth(root.right); return Math.max(lef...
2024王道数据结构 大题01-线性表的顺序存储
m0_53294028的博客
09-05 108
【代码】2024王道数据结构 大题01-线性表的顺序存储。
王道数据结构顺序表大题练习
qq_41225895的博客
01-14 310
顺序表 #include<iostream> #include<string> #include<iomanip> #include<stdlib.h> using namespace std; typedef struct LNode { int data; //结点的数据域 struct LNode *next; //结点的指针域 }LNode, *LinkList; //LinkList为指向结构体LNode的指针类型 bool InitList
王道数据结构的所有选择题.rar
09-07
"王道数据结构"是一本被广泛使用的教材，涵盖了线性表、栈、队列、链表、树、图、排序算法、查找算法等基础和进阶主题。这个RAR压缩文件似乎包含了该书所有选择题的资源，对于学习和复习数据结构非常有帮助。 1. **...
2024王道数据结构课后部分代码题
最新发布
04-16
"2024王道数据结构课后部分代码题"针对的是这一主题，特别是关于树的数据结构部分，这是一组用于学习和实践的代码题目。 树是一种非线性数据结构，它由节点（也称为顶点）和边组成，每个节点可以连接到零个或多个...
C语言数据结构之线索二叉树及其遍历
12-31
C语言数据结构之线索二叉树及其遍历 遍历二叉树就是以一定的规则将二叉树中的节点排列成一个线性序列，从而得到二叉树节点的各种遍历序列，其实质是：对一个非线性的结构进行线性化。使得在这个访问序列中每一个节点...
王道考研数据结构PPT
01-12
8. **堆**：堆是一种特殊的树形数据结构，满足堆属性（大顶堆或小顶堆）。堆通常用作优先队列的实现，也是某些排序算法（如堆排序）的基础。 9. **字符串**：字符串是字符序列，其操作包括拼接、查找、替换等。KMP...
王道考研——数据结构PPT.zip
08-21
数据结构是计算机科学中的核心课程之一，主要研究如何在计算机中组织、存储和管理数据，以便高效地进行各种操作。王道考研的数据结构PPT涵盖了这门学科的关键概念和技术，对于准备考研的学生来说，是一份非常有价值...
二叉树及相关题目
qq_41074616的博客
09-27 700
二叉树及相关题目 一、树 树是一种在实际编程中经常遇到的数据结构。它的逻辑很简单：除了根结点之外每个结点只有一个父结点；除了叶结点之外所有结点都有一个或多个子结点，叶结点没有子结点。父结点和子结点之间用指针链接。由于树的操作一般涉及大量的指针，因此一般与树有关的题目都稍显复杂。 二、二叉树 二叉树是树中最常见的一种。所谓二叉树也就是树的一种特殊结构，在二叉树中每个结点最多只能有两个子结点。一棵二叉树具有以下特点： 每个结点最多有两棵子树，所以二叉树中不存在度大于2的结点； 左子树和右子树是有顺序的，次序不
王道数据结构编程题（二叉树）
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
03-07 1953
王道数据结构编程题（二叉树）
考研王道数据结构第一个大题（持续更新）
weixin_46144832的博客
07-16 158
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> #define MaxSize 50 typedef int ElemType ; //定义顺序表 typedef struct{ ElemType data[MaxSize]; int length; }SqList; //初始化顺序表 void InitList(SqList &.
二叉树经典例题
qq_43533956的博客
03-18 1502
解决二叉树相关问题，常见的思路有两种，一是利用二叉树的遍历序列，二是利用递归，当然也可能是二者都有。 对称二叉树 判断一个二叉树是否关于root轴对称。 这道题看起来似乎可以用中序遍历解决，因为对称二叉树的中序序列一定是回文的。但是中序序列为回文的二叉树未必是对称的，比如上图中假如把两个叶子节点的值改为2，它的中序就是2,2,1,2,2，但是它并不对称。 这道题应该用递归来解决，不过注意如何比较左右子树 public class Solution { public bool IsSy
二叉树遍历和线索二叉树大题复习（王道教材）（上）
Six23333的博客
09-14 992
文章目录一、编写后序遍历二叉树的非递归算法1.1 思路1.2总程序二、试给出二叉树的自下而上，从右到左的层次遍历算法2.1思路2.2总程序三、假设二叉树采用二叉链表存储结构，设计一个非递归算法求二叉树的高度二叉链表存储结构表示3.1 思路3.2总程序四、设一棵二叉树中各结点的值互不相同，其先序遍历序列和中序遍历序列分别存于两个一维数组A[1...N]和B[1....N]中，试编写算法建立该二叉树的二叉链表4.1思路4.2总程序五、二叉树按二叉链表形式存储，写一个判别给定二叉树是否是完全二叉树的算法5.1思路
王道数据结构代码大题实现,可运行
m0_51185615的博客
08-29 416
第一题 从顺序表L中删除具有最小值的元素(假设唯一)并友函数返回被删元素的值。空出的元素由最后一个元素填补。 #include <bits/stdc++.h> using namespace std; #define Maxsize 100 typedef struct { int c[Maxsize]; int length; }Sqlist; //Sqlist Create01(int Maxsize, int length); bool DeleteMin(Sqlist &
二叉树-题型总结
31楼下小黑的博客
04-14 278
迭代遍历二叉树 使用栈把遍历过的结点压入栈，通过改变list.add(cur.val)的位置，实现非递归前序遍历和中序遍历。 Stack<Integer> stack = new Stack<>(); NodeTree cur = root; while(!stack.isEmpty() || cur != null){ while(cur != null){//这个wh............
王道数据结构精选习题及解析
weixin_43757333的博客
03-25 2214
而为了记录最小值结点的前置结点，我们还需要一个结点，专门作为当前工作结点的前一个结点，工作结点后移一步的过程中，要保持该前置结点是工作结点的前一个结点。链表有一个头结点，我们初始化时也为其保留一个结点，也就是图上的a1，然后我们依次遍历a2及其后面的结点，将其在合适的位置插入。由于我们没有新建一个链表，而是在原来的l1的基础上去改箭头，所以我们需要一个多的指针去存储l1当前工作指针的下一个指针。还有就是最后一步，循环完毕时，最后一个结点是没有指向前一个结点的，因此不能忘记这一步操作！
【数据结构】二叉树经典习题
weixin_61932507的博客
04-17 3417
【数据结构】二叉树经典习题
数据结构编程题二叉树
08-19
- *1* [王道数据结构编程题（二叉树）](https://blog.csdn.net/qq_43686863/article/details/123334790)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值