数据结构 - 二叉树

1.二叉树先序、中序、后序三种遍历

https://blog.csdn.net/chinesekobe/article/details/110874773

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 
 4 typedef struct node{
 5     int data;
 6     struct node *lchild;
 7     struct node *rchild;
 8 }N;
 9 
10 //构建二叉树
11 N *create()
12 {
13     int data;
14     N* p;
15     scanf("%d",&data);
16     if(-1 == data)
17     {
18         return NULL;
19     }
20     else
21     {
22         p = (N*)malloc(sizeof(N));
23         p->data = data;
24         printf("输入%d左子树\n",data);
25         p->lchild = create();
26         printf("输入%d右子树\n",data);
27         p->rchild = create();
28         return p;
29     }
30 }
31 
32 //先序遍历
33 void xianxu(N *p)
34 {
35     if(NULL == p)
36     {
37         return;
38     }
39     printf("%d ",p->data);
40     xianxu(p->lchild);
41     xianxu(p->rchild);
42 }
43 
44 //中序遍历
45 void zhongxu(N *p)
46 {
47     if(NULL == p)
48     {
49         return;
50     }
51     zhongxu(p->lchild);
52     printf("%d ",p->data);
53     zhongxu(p->rchild);
54 }
55 
56 //后序遍历
57 void houxu(N *p)
58 {
59     if(NULL == p)
60     {
61         return;
62     }
63     houxu(p->lchild);
64     houxu(p->rchild);
65     printf("%d ",p->data);
66 }
67 
68 int main()
69 {
70     N *p;
71     p = create();
72     printf("先序遍历\n");
73     xianxu(p);
74     printf("\n中序遍历\n");
75     zhongxu(p);
76     printf("\n后序遍历\n");
77     houxu(p);
78 
79     return 0;
80 }

c++用栈实现二叉树的中序遍历：

 1 #include <iostream>
 2 #include <vector>
 3 #include <stack>
 4 using namespace std;
 5 
 6 typedef struct node{
 7     int data;
 8     struct node *lchild;
 9     struct node *rchild;
10 }N;
11 
12 class node1{
13 public:
14      N *create(){
15         int data;
16         N* p;
17         cin >> data;
18         if(-1 == data) return NULL;
19         else{
20            p = new N;
21            p->data = data;
22            p->lchild = create();
23            p->rchild = create();
24            return p;
25          }
26      }
27     vector<int> inorder(N* root){
28         vector<int> ans;
29         N* cur = root;
30         stack<N*> stk;
31         while(cur || !stk.empty()){
32            while(cur){
33               stk.push(cur);
34               cur = cur->lchild;
35            }
36            cur = stk.top();stk.pop();
37            ans.push_back(cur->data);
38            cur = cur->rchild;
39         }
40         return ans;
41     }
42 };
43 
44 int main(){
45 
46    node1 n;
47    vector<int> ans;
48    N *p = n.create();
49    ans = n.inorder(p);
50    for(int i = 0;i<ans.size();i++){
51       cout << ans[i] << " ";
52    }
53    
54    return 0;
55 }

2.二叉树的深度

https://blog.csdn.net/weixin_48701521/article/details/107698584

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 
 4 typedef struct node{
 5     int data;
 6     struct node *lchild;
 7     struct node *rchild;
 8 }N;
 9 
10 //计算二叉树的深度
11 int shendu(N *p)
12 {
13     int zuo,you,sun;
14     if(NULL != p)
15     {
16         zuo = shendu(p->lchild);
17         you = shendu(p->rchild);
18         sun = (zuo > you ? zuo : you) + 1;
19         return sun;
20     }
21     else
22     {
23         return 0;
24     }
25 }
26 
27 //构建二叉树
28 N *create()
29 {
30     int data;
31     N* p;
32     scanf("%d",&data);
33     if(-1 == data)
34     {
35         return NULL;
36     }
37     else
38     {
39         p = (N*)malloc(sizeof(N));
40         p->data = data;
41         printf("输入%d左子树\n",data);
42         p->lchild = create();
43         printf("输入%d右子树\n",data);
44         p->rchild = create();
45         return p;
46     }
47 }
48 
49 int main()
50 {
51     N *p;
52     p = create();
53     int i = shendu(p);
54     printf("二叉树的深度为%d\n",i);
55 
56     return 0;
57 }

3.二叉树的层次遍历

https://blog.csdn.net/lei2014lei/article/details/85166712

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 
  4 #define INITQUEUE 20
  5 
  6 typedef struct BiTNode
  7 {
  8     char data;
  9     struct BiTNode *lchild;
 10     struct BiTNode *rchild;
 11 }BiTNode,*BiTree;
 12 
 13 typedef struct Queue
 14 {
 15     BiTNode *front;
 16     BiTNode *tail;
 17     int size;
 18 }Queue;
 19 
 20 //创建队列
 21 int InitQueue(Queue &Q)
 22 {
 23     Q.front = (BiTNode*)malloc(INITQUEUE * sizeof(BiTNode));
 24     if(!Q.front)
 25     {
 26         return 0;
 27     }
 28     Q.tail = Q.front;
 29     Q.size = INITQUEUE;
 30     return 1;
 31 }
 32 
 33 //判断队列是否为空
 34 int EmptyQueue(Queue Q)
 35 {
 36     if(Q.tail == Q.front)
 37     {
 38         return 1;
 39     }
 40     else
 41     {
 42         return 0;
 43     }
 44 }
 45 
 46 //入队列
 47 int EnQueue(Queue &Q,BiTNode e)
 48 {
 49     if((Q.tail - Q.front + INITQUEUE) % INITQUEUE == INITQUEUE - 1)
 50     {
 51         return 0;
 52     }
 53     *Q.tail = e;
 54     Q.tail++;
 55     return 1;
 56 }
 57 
 58 //出队列
 59 int DeQueue(Queue &Q,BiTNode &e)
 60 {
 61     if(Q.front == Q.tail)
 62     {
 63         return 0;
 64     }
 65     e = *Q.front;
 66     Q.front++;
 67     return 1;
 68 }
 69 
 70 //创建二叉树
 71 void CreateBiTree(BiTree &T)
 72 {
 73     char ch;
 74     scanf("%c",&ch);
 75     if('#' == ch)
 76     {
 77         T = NULL;
 78     }
 79     else
 80     {
 81         T = (BiTree)malloc(sizeof(BiTNode));
 82         T->data = ch;
 83         CreateBiTree(T->lchild);
 84         CreateBiTree(T->rchild);
 85     }
 86 }
 87 
 88 //二叉树的层次遍历
 89 int levelTraverse(BiTree T)
 90 {
 91     if(NULL == T)
 92     {
 93         return 0;
 94     }
 95     Queue Q;
 96     BiTNode e;
 97     int curlevel = 1;//本层剩余的未访问的节点数
 98     int nextlevel = 0;//下一层未访问的节点数
 99     int levelcount = 0;//树的深度
100     InitQueue(Q);
101     EnQueue(Q,*T);
102     while(!EmptyQueue(Q))
103     {
104         DeQueue(Q,e);
105         printf("%c ",e.data);
106         curlevel--;
107         if(NULL != e.lchild)
108         {
109             EnQueue(Q,*e.lchild);
110             nextlevel ++;
111         }
112         if(NULL != e.rchild)
113         {
114             EnQueue(Q,*e.rchild);
115             nextlevel++;
116         }
117         if(0 == curlevel)
118         {
119             levelcount++;
120             printf("第%d层节点遍历结束!\n",levelcount);
121             curlevel = nextlevel;
122             nextlevel =0;
123         }
124     }
125     return 1;
126 }
127 
128 int main()
129 {
130     BiTree T = NULL;
131     CreateBiTree(T);
132     levelTraverse(T);
133     return 0;
134 }

c++实现：

 1 #include <iostream>
 2 #include <vector>
 3 #include <queue>
 4 using namespace std;
 5 
 6 typedef struct node{
 7      int data;
 8      struct node *lchild;
 9      struct node *rchild;
10 }N; 
11 
12 class node1{
13 public:
14       N *create(){
15          int data;
16          N* p;
17          cin >> data;
18          if(-1 == data) return NULL;
19          else{
20             p = new N;
21             p->data = data;
22             p->lchild = create();
23             p->rchild = create();
24              return p;
25           }
26       }
27       vector<vector<int>> level(N* root){
28           vector<vector<int>> ans;
29           if(!root) return ans;
30           
31           queue<N*> q;
32           q.push(root);
33           
34           while(!q.empty()){
35               int cnt = q.size();
36               vector<int> cur;
37               while(cnt--){
38                   N* p = q.front();q.pop();
39                   cur.push_back(p->data);
40                   if(p->lchild) q.push(p->lchild);
41                   if(p->rchild) q.push(p->rchild);
42               }
43               ans.push_back(cur);
44           }
45       }
46 };
47 
48 int main()
49 {
50    node1 n;
51    vector<vector<int>> cur;
52    N* p = n.create();
53    cur = n.level(p);
54    for(int i = 0;i<cur.size();i++){
55      for(int j = 0;j<cur[i].size();j++){
56          cout << cur[i][j] << " ";
57      }
58      cout << endl;
59    }
60     
61    return 0;
62 }

4.反转二叉树

https://blog.csdn.net/ASZZY/article/details/88900324

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 
 4 typedef struct Tree{
 5  
 6  int data;                    //    存放数据域
 7  struct Tree *lchild;            //    遍历左子树指针
 8  struct Tree *rchild;            //    遍历右子树指针
 9  
10 }Tree,*BitTree;
11 
12 BitTree CreateLink()
13 {
14     int data;
15     int temp;
16     BitTree T;
17     
18     scanf("%d",&data);        //    输入数据
19     temp=getchar();            //    吸收空格
20     
21     if(data == -1){            //    输入-1 代表此节点下子树不存数据，也就是不继续递归创建
22         
23         return NULL;
24 
25     }else{
26         T = (BitTree)malloc(sizeof(Tree));            //        分配内存空间
27         T->data = data;                                //        把当前输入的数据存入当前节点指针的数据域中
28         
29         printf("请输入%d的左子树: \n",data);        
30         T->lchild = CreateLink();                    //        开始递归创建左子树
31         printf("请输入%d的右子树: \n",data);            
32         T->rchild = CreateLink();                    //        开始到上一级节点的右边递归创建左右子树
33         return T;                            //        返回根节点
34     }    
35     
36 }
37 //    先序遍历
38 void ShowXianXu(BitTree T)            //        先序遍历二叉树
39 {
40     if(T==NULL)                        //    递归中遇到NULL，返回上一层节点
41     {
42         return;
43     }
44     printf("%d ",T->data);
45     ShowXianXu(T->lchild);            //    递归遍历左子树
46     ShowXianXu(T->rchild);            //    递归遍历右子树
47 }
48 
49 BitTree invertTree(BitTree root) 
50 {
51     if(root == NULL)
52         return NULL;
53     BitTree p = root;
54     p = root->lchild;
55     root->lchild = root->rchild;
56     root->rchild = p;
57     invertTree(root->lchild);
58     invertTree(root->rchild);
59     return root;
60 }
61 
62 
63 int main() 
64 {
65     BitTree b;
66     b= CreateLink();
67     ShowXianXu(b);
68     printf("\n反转二叉树\n");
69     b = invertTree(b);
70     ShowXianXu(b);
71     
72     return 0;
73 }

5.判断二叉树是不是平衡二叉树

https://blog.csdn.net/sessos/article/details/109101335

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 
 4 typedef struct Tree{
 5  
 6  int data;                    //    存放数据域
 7  struct Tree *lchild;            //    遍历左子树指针
 8  struct Tree *rchild;            //    遍历右子树指针
 9  
10 }Tree,*BitTree;
11 
12 BitTree CreateLink()
13 {
14     int data;
15     int temp;
16     BitTree T;
17     
18     scanf("%d",&data);        //    输入数据
19     temp=getchar();            //    吸收空格
20     
21     if(data == -1){            //    输入-1 代表此节点下子树不存数据，也就是不继续递归创建
22         
23         return NULL;
24 
25     }else{
26         T = (BitTree)malloc(sizeof(Tree));            //        分配内存空间
27         T->data = data;                                //        把当前输入的数据存入当前节点指针的数据域中
28         
29         printf("请输入%d的左子树: \n",data);        
30         T->lchild = CreateLink();                    //        开始递归创建左子树
31         printf("请输入%d的右子树: \n",data);            
32         T->rchild = CreateLink();                    //        开始到上一级节点的右边递归创建左右子树
33         return T;                            //        返回根节点
34     }    
35     
36 }
37 //    先序遍历
38 void ShowXianXu(BitTree T)            //        先序遍历二叉树
39 {
40     if(T==NULL)                        //    递归中遇到NULL，返回上一层节点
41     {
42         return;
43     }
44     printf("%d ",T->data);
45     ShowXianXu(T->lchild);            //    递归遍历左子树
46     ShowXianXu(T->rchild);            //    递归遍历右子树
47 }
48 
49 int getHeight(BitTree root)
50 {
51     if(root == NULL)
52     {
53         return 0;
54     }
55  
56     int Hleft = getHeight(root->lchild);
57     int Hright = getHeight(root->rchild);
58     int h = Hleft > Hright ? Hleft:Hright;
59     return h + 1;
60 }
61 
62 bool isBalancedTree(BitTree root)
63 {
64     if(root == NULL)    return true;
65     int Lh = getHeight(root->lchild);
66     int Rh = getHeight(root->rchild);
67     int h = Lh - Rh;
68     if(h < -1 || h > 1)
69     {
70         return false;
71     }
72  
73     bool Ltree = isBalancedTree(root->lchild);
74     bool Rtree = isBalancedTree(root->rchild);
75     if(!Ltree || !Rtree)
76     {
77         return false;
78     }
79  
80     return true;
81 }
82 
83 int main() 
84 {
85     BitTree b;
86     b= CreateLink();
87     ShowXianXu(b);
88     if(isBalancedTree(b))
89     {
90        printf("\n该二叉树是平衡二叉树\n"); 
91     }
92     else
93     {
94         printf("\n该二叉树不是平衡二叉树\n");
95     }
96     
97     return 0;
98 }

6.另一个树的子树

给定两个非空二叉树s和t，检验s中是否包含和t具有相同结构和节点值的子树。

https://blog.csdn.net/qq_42433334/article/details/104794327

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 
 4 typedef struct Tree{
 5  
 6  int data;                    //    存放数据域
 7  struct Tree *lchild;            //    遍历左子树指针
 8  struct Tree *rchild;            //    遍历右子树指针
 9  
10 }Tree,*BitTree;
11 
12 BitTree CreateLink()
13 {
14     int data;
15     int temp;
16     BitTree T;
17     
18     scanf("%d",&data);        //    输入数据
19     temp=getchar();            //    吸收空格
20     
21     if(data == -1){            //    输入-1 代表此节点下子树不存数据，也就是不继续递归创建
22         
23         return NULL;
24 
25     }else{
26         T = (BitTree)malloc(sizeof(Tree));            //        分配内存空间
27         T->data = data;                                //        把当前输入的数据存入当前节点指针的数据域中
28         
29         printf("请输入%d的左子树: ",data);        
30         T->lchild = CreateLink();                    //        开始递归创建左子树
31         printf("请输入%d的右子树: ",data);            
32         T->rchild = CreateLink();                    //        开始到上一级节点的右边递归创建左右子树
33         return T;                            //        返回根节点
34     }    
35     
36 }
37 
38 bool compare(BitTree root1,BitTree root2)
39 {
40     if(root1 == NULL && root2 == NULL)
41         return true;
42     if(root1 == NULL || root2 == NULL)
43         return false;
44     if(root1->data != root2->data)
45         return false;
46     return compare(root1->lchild,root2->lchild) && compare(root1->rchild,root2->rchild);  //递归比较左右  
47 }
48  
49 bool isSubtree(BitTree s, BitTree t)
50 {
51      if(s == NULL && t != NULL)   //s已经到底
52          return false;
53     return compare(s,t) || isSubtree(s->lchild,t) || isSubtree(s->rchild,t);  //判 根  左  右
54 }
55 
56 int main()
57 {
58     BitTree b,c;
59     b = CreateLink();
60     c = CreateLink();
61     if(isSubtree(b, c))
62     {
63        printf("存在\n");
64     }
65     else
66     {
67         printf("不存在\n");
68     }
69     
70     return 0;
71 }

7.相同的树

给定两个二叉树，编写一个函数来检验他们是否相等，如果两个树在结构上相同，并且节点具有相同的值，则认为他们是相同的。

https://blog.csdn.net/qq_42433334/article/details/104794327

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 
 4 typedef struct Tree{
 5  
 6  int data;                    //    存放数据域
 7  struct Tree *lchild;            //    遍历左子树指针
 8  struct Tree *rchild;            //    遍历右子树指针
 9  
10 }Tree,*BitTree;
11 
12 BitTree CreateLink()
13 {
14     int data;
15     int temp;
16     BitTree T;
17     
18     scanf("%d",&data);        //    输入数据
19     temp=getchar();            //    吸收空格
20     
21     if(data == -1){            //    输入-1 代表此节点下子树不存数据，也就是不继续递归创建
22         
23         return NULL;
24 
25     }else{
26         T = (BitTree)malloc(sizeof(Tree));            //        分配内存空间
27         T->data = data;                                //        把当前输入的数据存入当前节点指针的数据域中
28         
29         printf("请输入%d的左子树: ",data);        
30         T->lchild = CreateLink();                    //        开始递归创建左子树
31         printf("请输入%d的右子树: ",data);            
32         T->rchild = CreateLink();                    //        开始到上一级节点的右边递归创建左右子树
33         return T;                            //        返回根节点
34     }        
35 }
36 
37 bool isSameTree(BitTree p, BitTree q)
38 {
39 if(p==NULL && q==NULL)
40     return true;
41 if(p==NULL || q==NULL)
42     return false;
43 if(p->data != q->data)
44     return false;
45  
46 return isSameTree(p->lchild,q->lchild)&&isSameTree(p->rchild,q->rchild);
47 }
48 
49 int main()
50 {
51     BitTree b,c;
52     b = CreateLink();
53     c = CreateLink();
54     if(isSameTree(b,c))
55     {
56        printf("相同\n");
57     }
58     else
59     {
60         printf("不相同\n");
61     }
62     
63     return 0;
64 }

8.对称二叉树

https://blog.csdn.net/m0_57330725/article/details/122486045

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 
 4 typedef struct Tree{
 5  
 6  int data;                    //    存放数据域
 7  struct Tree *lchild;            //    遍历左子树指针
 8  struct Tree *rchild;            //    遍历右子树指针
 9  
10 }Tree,*BitTree;
11 
12 BitTree CreateLink()
13 {
14     int data;
15     int temp;
16     BitTree T;
17     
18     scanf("%d",&data);        //    输入数据
19     temp=getchar();            //    吸收空格
20     
21     if(data == -1){            //    输入-1 代表此节点下子树不存数据，也就是不继续递归创建
22         
23         return NULL;
24 
25     }else{
26         T = (BitTree)malloc(sizeof(Tree));            //        分配内存空间
27         T->data = data;                                //        把当前输入的数据存入当前节点指针的数据域中
28         
29         printf("请输入%d的左子树: ",data);        
30         T->lchild = CreateLink();                    //        开始递归创建左子树
31         printf("请输入%d的右子树: ",data);            
32         T->rchild = CreateLink();                    //        开始到上一级节点的右边递归创建左右子树
33         return T;                            //        返回根节点
34     }        
35 }
36 
37 bool _isSymmetric(BitTree root1,BitTree root2)//判断为左右子树的值是不是相等
38 {
39     if(root1==NULL&&root2==NULL)
40     {
41         return true;
42     }
43     if(root1==NULL||root2==NULL)
44     {
45         return false;
46     }
47     if(root1->data!=root2->data)
48     {
49         return false;
50     }
51     return _isSymmetric(root1->lchild,root2->rchild)&&_isSymmetric(root1->rchild,root2->lchild);//对后续进行递归
52 }
53 
54 bool isSymmetric(BitTree root)
55 {
56     if(root==NULL)
57     {
58         return true;
59     }
60  return _isSymmetric(root->lchild,root->rchild);
61    
62 }
63 
64 int main()
65 {
66     BitTree b,c;
67     b = CreateLink();
68     if(isSymmetric(b))
69     {
70        printf("对称\n");
71     }
72     else
73     {
74         printf("不对称\n");
75     }
76     return 0;
77 }

9.左叶子之和

https://blog.csdn.net/MDJ_D2T/article/details/108853531

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 
 4 typedef struct Tree{
 5  
 6  int data;                    //    存放数据域
 7  struct Tree *lchild;            //    遍历左子树指针
 8  struct Tree *rchild;            //    遍历右子树指针
 9  
10 }Tree,*BitTree;
11 
12 BitTree CreateLink()
13 {
14     int data;
15     int temp;
16     BitTree T;
17     
18     scanf("%d",&data);        //    输入数据
19     temp=getchar();            //    吸收空格
20     
21     if(data == -1){            //    输入-1 代表此节点下子树不存数据，也就是不继续递归创建
22         
23         return NULL;
24 
25     }else{
26         T = (BitTree)malloc(sizeof(Tree));            //        分配内存空间
27         T->data = data;                                //        把当前输入的数据存入当前节点指针的数据域中
28         
29         printf("请输入%d的左子树: ",data);        
30         T->lchild = CreateLink();                    //        开始递归创建左子树
31         printf("请输入%d的右子树: ",data);            
32         T->rchild = CreateLink();                    //        开始到上一级节点的右边递归创建左右子树
33         return T;                            //        返回根节点
34     }        
35 }
36 
37 int GetLeftLeaveSum(BitTree root, int flag)
38 {
39      int ileft, iright;
40     /*为空则返回0*/
41     if(root == NULL)
42         return 0;
43     /*为左叶子节点则返回节点值*/
44     if(root->lchild == NULL && root->rchild == NULL && flag == 0)
45         return root->data;
46 
47     ileft = GetLeftLeaveSum(root->lchild,0);
48     iright = GetLeftLeaveSum(root->rchild,1);
49     
50     return ileft + iright;
51  }
52 
53 int sumOfLeftLeaves(BitTree root)
54 {
55     BitTree node = NULL;
56     /*根节点不是左节点，标志传1*/
57     return GetLeftLeaveSum(root,1);
58 }
59 
60 int main()
61 {
62     BitTree b,c;
63     b = CreateLink();
64     printf("左叶子之和%d\n",sumOfLeftLeaves(b));
65     
66     return 0;
67 }

10.将有序数组转换为二叉搜索树

https://blog.csdn.net/qq_42007287/article/details/104522602

https://blog.csdn.net/qq_51277752/article/details/122310634

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 
 4 typedef struct Tree{
 5  
 6  int data;                    //    存放数据域
 7  struct Tree *lchild;            //    遍历左子树指针
 8  struct Tree *rchild;            //    遍历右子树指针
 9  
10 }Tree,*BitTree;
11 
12 //    先序遍历
13 void ShowXianXu(BitTree T)            //        先序遍历二叉树
14 {
15     if(T==NULL)                        //    递归中遇到NULL，返回上一层节点
16     {
17         return;
18     }
19     printf("%d ",T->data);
20     ShowXianXu(T->lchild);            //    递归遍历左子树
21     ShowXianXu(T->rchild);            //    递归遍历右子树
22 }
23 
24 BitTree sortedArrayToBST__(int *nums, int l, int r) 
25 {
26     if (l > r) return NULL;
27     int mid = (l + r) / 2;
28     Tree* node = (Tree*)malloc(sizeof(Tree));
29     node->data = nums[mid];
30     node->lchild = sortedArrayToBST__(nums, l, mid - 1);
31     node->rchild = sortedArrayToBST__(nums, mid + 1, r);
32     return node;
33 }
34 
35 BitTree sortedArrayToBST(int* nums, int numsSize)
36 {
37     BitTree head = sortedArrayToBST__(nums, 0, numsSize - 1);
38     return head;
39 }
40 
41 int main()
42 {
43     BitTree b;
44     int nuns[] = {-10,-3,0,5,9};
45     b = sortedArrayToBST(nuns, 5);
46     ShowXianXu(b);
47     
48     return 0;
49 }