码迷，mamicode.com
首页 > 编程语言 > 详细

数据结构与算法--二叉树（一）

时间：2016-04-22 10:37:48      阅读：318      评论：0      收藏：0      [点我收藏+]

标签：


1 基于二叉链表的有序二叉树

1.1 问题

BST是Binary Search Tree的缩写，译为二叉搜索树，或有序二叉树，是二叉树的一种，它的定义如下：

1)或者是一棵空树；

2)或者是具有下列性质的二叉树：

I) 若左子树不空，则左子树上所有结点的值均小于它的根结点的值；

II) 若右子树不空，则右子树上所有结点的值均大于它的根结点的值；

III)左、右子树也分别为二叉排序树；

BST在查找一个结点或插入一个结点时，具有极大的优势，速度非常快。是一种基础性数据结构，广泛应用于更加抽象的集合、关联数组等数据结构。

1.2 方案

BST的基本操作包括：

1) 创建结点，新生成一个结点用于向BST中添加。

2) 增加结点，在BST中加入一个数据元素。

3) 删除结点，在BST中删除一个数据元素。

4) 查找结点，在BST中查找指定的数据是否存在，如果存在则得到其地址。

5) 修改结点，对BST中指定的数据进行修改。

6) 清除一棵树

1.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义BST结点结构

在C语言中：

1)定义一个变量data，用来模拟BST中的数据。

2)定义一个指针left，用于指向该结点的左孩子。

3)定义一个指针right，用于指向该结点的右孩子。

4)这三方面的信息共同描述一个BST结点，可将它们封装在一起。

代码如下：

  1. typedef int DataType;
  2. struct Node{
  3.     DataType data;
  4.     struct Node *left;
  5.     struct Node *right;
  6. };

步骤二：创建结点

首先，向操作系统申请一块存储空间。

然后，存储数据域数据

最后，将左孩子和右孩子指针赋值为空。

代码如下所示：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef int DataType;
  5. struct Node{
  6.     DataType data;
  7.     struct Node *left;
  8.     struct Node *right;
  9. };
  11. //创建一个节点
  12. struct Node* createNode(DataType d)
  13. {
  14.     struct Node *pn = (struct Node*)malloc(sizeof(struct Node));
  15.     pn->data = d;
  16.     pn->left = pn->right = NULL;
  17.     return pn;
  18. }

步骤三：增加结点

首先，判断要插入的结点是否存在。

然后，判断根结点是否为空。

1)若根结点不为空，则当要插入的结点数据大于根结点的数据时，插入右子树；否则插入左子树。

2)若根结点为空，则将新加入的结点添加到根结点处。

代码如下所示：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef int DataType;
  5. struct Node{
  6.     DataType data;
  7.     struct Node *left;
  8.     struct Node *right;
  9. };
  11. //创建一个节点
  12. struct Node* createNode(DataType d)
  13. {
  14.     struct Node *pn = (struct Node*)malloc(sizeof(struct Node));
  15.     pn->data = d;
  16.     pn->left = pn->right = NULL;
  17.     return pn;
  18. }
  20. //讲一个节点插入到一个树中
  21. void insert(struct Node** root, struct Node* pn) {
  22.     if (pn == NULL) return;
  23.     //树为空
  24.     if (*root == NULL) {*root = pn; return;}
  25.     //树不为空
  26.     if (pn->data > (*root)->data) {
  27.         insert(&(*root)->right, pn);
  28.     }else {
  29.         insert(&(*root)->left, pn);
  30.     }
  31. }

步骤四：删除结点

首先，查找要删除的结点，若不存在，则直接返回。

然后，若要被删除的结点没有左子树，则作如下处理：

1)要被删除的结点的双亲结点不存在时，则表明要删除根结点，此时只需将要删除结点的右孩子结点变成根结点即可。

2)要被删除的结点是其双亲结点的左孩子时，将要删除结点的右子树变成双亲结点的左孩子即可。

3) 要被删除的结点是其双亲结点的右孩子时，将要删除结点的右子树变成双亲结点的右孩子即可。

4)释放要被删除结点所占的存储空间。

最后，若要被删除的结点有左子树，则作如下处理：

1)在要删除结点的左子树中查找最右下的结点。

2)如果最右下结点的双亲结点与被删除结点是同一结点，则将最右下结点的双亲结点的左孩子变为最右下结点的左孩子。

3)如果最右下结点的双亲结点与被删除结点不是同一结点，则将最右下结点的双亲结点的右孩子变为最右下结点的左孩子。

4)将最右下结点的数据复制到要删除结点内。

5)释放最右下结点所占的存储空间。

代码如下：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef int DataType;
  5. struct Node{
  6.     DataType data;
  7.     struct Node *left;
  8.     struct Node *right;
  9. };
  11. //创建一个节点
  12. struct Node* createNode(DataType d)
  13. {
  14.     struct Node *pn = (struct Node*)malloc(sizeof(struct Node));
  15.     pn->data = d;
  16.     pn->left = pn->right = NULL;
  17.     return pn;
  18. }
  20. //讲一个节点插入到一个树中
  21. void insert(struct Node** root, struct Node* pn) {
  22.     if (pn == NULL) return;
  23.     //树为空
  24.     if (*root == NULL) {*root = pn; return;}
  25.     //树不为空
  26.     if (pn->data > (*root)->data) {
  27.         insert(&(*root)->right, pn);
  28.     }else {
  29.         insert(&(*root)->left, pn);
  30.     }
  31. }
  33. //在二叉排序树t中删去关键字为k的结点
  34. void delete(struct Node** root, DataType k)
  35. {
  36.     struct Node* p, *f, *s, *q;
  37.     p=*root;
  38.     f=NULL;
  39.     while(p)//查找关键字为k的待删结点p
  40.     {
  41.         if(p->data==k )  break;  //找到则跳出循环
  42.         f=p;   //f指向p结点的双亲结点
  43.         if(p->data>k)
  44.             p=p->left;
  45.         else
  46.             p=p->right;
  47.     }
  48.     if(p==NULL)  return;  //若找不到，返回原来的二叉排序树
  49.     if(p->left==NULL)  //p无左子树
  50.     {
  51.         if(f==NULL)
  52.             *root=p->right;  //p是原二叉排序树的根
  53.         else if(f->left==p)  //p是f的左孩子
  54.             f->left=p->right;   //将p的右子树链到f的左链上
  55.         else  //p是f的右孩子
  56.             f->right=p->right;   //将p的右子树链到f的右链上
  57.         free(p);
  58.     }
  59.     else  //p有左子树
  60.     {
  61.         q=p;
  62.         s=p->left;
  63.         while(s->right)  //在p的左子树中查找最右下结点
  64.         {
  65.             q=s;
  66.             s=s->right;
  67.         }
  68.         if(q==p)
  69.             q->left=s->left;   //将s的左子树链到q上
  70.         else
  71.             q->right=s->left;
  72.         p->data=s->data;  //将s的值赋给p
  73.         free(s);
  74.     }
  75. }

上述代码中，以下代码：

  1.     while(p)//查找关键字为k的待删结点p
  2.     {
  3.         if(p->data==k )  break;  //找到则跳出循环
  4.         f=p;   //f指向p结点的双亲结点
  5.         if(p->data>k)
  6.             p=p->left;
  7.         else
  8.             p=p->right;
  9.     }
  10.     if(p==NULL)  return;  //若找不到，返回原来的二叉排序树

设置循环查找要删除的结点，若不存在，则直接返回。

上述代码中，以下代码：

  1.     if(p->left==NULL)  //p无左子树
  2.     {
  3.         if(f==NULL)
  4.             *root=p->right;  //p是原二叉排序树的根
  5.         else if(f->left==p)  //p是f的左孩子
  6.             f->left=p->right;   //将p的右子树链到f的左链上
  7.         else  //p是f的右孩子
  8.             f->right=p->right;   //将p的右子树链到f的右链上
  9.         free(p);
  10.     }

是若要被删除的结点没有左子树时的情形，其中指针p指向要被删除的结点，指针f指向被删除的结点的双亲结点。

  1.         if(f==NULL)
  2.             *root=p->right;  //p是原二叉排序树的根

表示要被删除的结点的双亲结点不存在时，要删除根结点。

  1.         else if(f->left==p)  //p是f的左孩子
  2.             f->left=p->right;   //将p的右子树链到f的左链上

表示要被删除的结点是其双亲结点的左孩子时，将要删除结点的右子树变成双亲结点的左孩子即可。

  1.         else  //p是f的右孩子
  2.             f->right=p->right;   //将p的右子树链到f的右链上

表示要被删除的结点是其双亲结点的右孩子时，将要删除结点的右子树变成双亲结点的右孩子即可。

上述代码中，以下代码：

  1.     else  //p有左子树
  2.     {
  3.         q=p;
  4.         s=p->left;
  5.         while(s->right)  //在p的左子树中查找最右下结点
  6.         {
  7.             q=s;
  8.             s=s->right;
  9.         }
  10.         if(q==p)
  11.             q->left=s->left;   //将s的左子树链到q上
  12.         else
  13.             q->right=s->left;
  14.         p->data=s->data;  //将s的值赋给p
  15.         free(s);
  16.     }

是若要被删除的结点有左子树时的情形，其中指针p指向要被删除的结点，指针s指向最右下结点，指针q指向最右下结点的双亲结点。

  1.         s=p->left;
  2.         while(s->right)  //在p的左子树中查找最右下结点
  3.         {
  4.             q=s;
  5.             s=s->right;
  6.         }

是在要删除结点的左子树中查找最右下的结点。

  1.         if(q==p)
  2.             q->left=s->left;   //将s的左子树链到q上

表示如果最右下结点的双亲结点q与被删除结点p是同一结点，则将最右下结点的双亲结点q的左孩子q->left变为最右下结点s的左孩子s->left。

  1.         else
  2.             q->right=s->left;

表示如果最右下结点的双亲结点q与被删除结点p不是同一结点，则将最右下结点的双亲结点q的右孩子q->right变为最右下结点s的左孩子s->left。

步骤五：查找结点

首先，判断根结点是否为空，若是则直接返回NULL。

然后，在根结点不为空的情况下，若要查找的数据大于根结点数据，遍历右子树查找。

下一步，在根结点不为空的情况下，若要查找的数据小于根结点数据，遍历左子树查找。

最后，在根结点不为空的情况下，若要查找的数据等于根结点数据，则返回根结点。

代码如下：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef int DataType;
  5. struct Node{
  6.     DataType data;
  7.     struct Node *left;
  8.     struct Node *right;
  9. };
  11. //创建一个节点
  12. struct Node* createNode(DataType d)
  13. {
  14.     struct Node *pn = (struct Node*)malloc(sizeof(struct Node));
  15.     pn->data = d;
  16.     pn->left = pn->right = NULL;
  17.     return pn;
  18. }
  20. //讲一个节点插入到一个树中
  21. void insert(struct Node** root, struct Node* pn) {
  22.     if (pn == NULL) return;
  23.     //树为空
  24.     if (*root == NULL) {*root = pn; return;}
  25.     //树不为空
  26.     if (pn->data > (*root)->data) {
  27.         insert(&(*root)->right, pn);
  28.     }else {
  29.         insert(&(*root)->left, pn);
  30.     }
  31. }
  33. //在二叉排序树t中删去关键字为k的结点
  34. void delete(struct Node** root, DataType k)
  35. {
  36.     struct Node* p, *f, *s, *q;
  37.     p=*root;
  38.     f=NULL;
  39.     while(p)//查找关键字为k的待删结点p
  40.     {
  41.         if(p->data==k )  break;  //找到则跳出循环
  42.         f=p;   //f指向p结点的双亲结点
  43.         if(p->data>k)
  44.             p=p->left;
  45.         else
  46.             p=p->right;
  47.     }
  48.     if(p==NULL)  return;  //若找不到，返回原来的二叉排序树
  49.     if(p->left==NULL)  //p无左子树
  50.     {
  51.         if(f==NULL)
  52.             *root=p->right;  //p是原二叉排序树的根
  53.         else if(f->left==p)  //p是f的左孩子
  54.             f->left=p->right;   //将p的右子树链到f的左链上
  55.         else  //p是f的右孩子
  56.             f->right=p->right;   //将p的右子树链到f的右链上
  57.         free(p);
  58.     }
  59.     else  //p有左子树
  60.     {
  61.         q=p;
  62.         s=p->left;
  63.         while(s->right)  //在p的左子树中查找最右下结点
  64.         {
  65.             q=s;
  66.             s=s->right;
  67.         }
  68.         if(q==p)
  69.             q->left=s->left;   //将s的左子树链到q上
  70.         else
  71.             q->right=s->left;
  72.         p->data=s->data;  //将s的值赋给p
  73.         free(s);
  74.     }
  75. }
  77. //查找一个树
  78. struct Node* find(struct Node* root, DataType d){
  79.     if(root == NULL)
  80.         return NULL;
  81.     if(d > root->data) //查找右子树
  82.         return find(root->right,d);
  83.     else if(d < root->data) //查找左子树
  84.         return find(root->left,d);
  85.     else
  86.         return root;
  87. }

步骤六：修改结点

首先，使用步骤四的方法查找到要修改的结点。

然后，将要修改的结点数据修改为指定数据。

代码如下：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef int DataType;
  5. struct Node{
  6.     DataType data;
  7.     struct Node *left;
  8.     struct Node *right;
  9. };
  11. //创建一个节点
  12. struct Node* createNode(DataType d)
  13. {
  14.     struct Node *pn = (struct Node*)malloc(sizeof(struct Node));
  15.     pn->data = d;
  16.     pn->left = pn->right = NULL;
  17.     return pn;
  18. }
  20. //讲一个节点插入到一个树中
  21. void insert(struct Node** root, struct Node* pn) {
  22.     if (pn == NULL) return;
  23.     //树为空
  24.     if (*root == NULL) {*root = pn; return;}
  25.     //树不为空
  26.     if (pn->data > (*root)->data) {
  27.         insert(&(*root)->right, pn);
  28.     }else {
  29.         insert(&(*root)->left, pn);
  30.     }
  31. }
  33. //在二叉排序树t中删去关键字为k的结点
  34. void delete(struct Node** root, DataType k)
  35. {
  36.     struct Node* p, *f, *s, *q;
  37.     p=*root;
  38.     f=NULL;
  39.     while(p)//查找关键字为k的待删结点p
  40.     {
  41.         if(p->data==k )  break;  //找到则跳出循环
  42.         f=p;   //f指向p结点的双亲结点
  43.         if(p->data>k)
  44.             p=p->left;
  45.         else
  46.             p=p->right;
  47.     }
  48.     if(p==NULL)  return;  //若找不到，返回原来的二叉排序树
  49.     if(p->left==NULL)  //p无左子树
  50.     {
  51.         if(f==NULL)
  52.             *root=p->right;  //p是原二叉排序树的根
  53.         else if(f->left==p)  //p是f的左孩子
  54.             f->left=p->right;   //将p的右子树链到f的左链上
  55.         else  //p是f的右孩子
  56.             f->right=p->right;   //将p的右子树链到f的右链上
  57.         free(p);
  58.     }
  59.     else  //p有左子树
  60.     {
  61.         q=p;
  62.         s=p->left;
  63.         while(s->right)  //在p的左子树中查找最右下结点
  64.         {
  65.             q=s;
  66.             s=s->right;
  67.         }
  68.         if(q==p)
  69.             q->left=s->left;   //将s的左子树链到q上
  70.         else
  71.             q->right=s->left;
  72.         p->data=s->data;  //将s的值赋给p
  73.         free(s);
  74.     }
  75. }
  77. //查找一个树
  78. struct Node* find(struct Node* root, DataType d){
  79.     if(root == NULL)
  80.         return NULL;
  81.     if(d > root->data) //查找右子树
  82.         return find(root->right,d);
  83.     else if(d < root->data) //查找左子树
  84.         return find(root->left,d);
  85.     else
  86.         return root;
  87. }
  89. //修改树中结点的值
  90. void modify(struct Node* root, DataType oldData, DataType newData)
  91. {
  92.     struct Node* p;
  93.     p = find(root, oldData);
  94.     p->data = newData;
  95. }

1.4 完整代码

本案例的完整代码如下所示：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. typedef int DataType;
  5. struct Node{
  6.     DataType data;
  7.     struct Node *left;
  8.     struct Node *right;
  9. };
  11. //创建一个节点
  12. struct Node* createNode(DataType d)
  13. {
  14.     struct Node *pn = (struct Node*)malloc(sizeof(struct Node));
  15.     pn->data = d;
  16.     pn->left = pn->right = NULL;
  17.     return pn;
  18. }
  20. //讲一个节点插入到一个树中
  21. void insert(struct Node** root, struct Node* pn) {
  22.     if (pn == NULL) return;
  23.     //树为空
  24.     if (*root == NULL) {*root = pn; return;}
  25.     //树不为空
  26.     if (pn->data > (*root)->data) {
  27.         insert(&(*root)->right, pn);
  28.     }else {
  29.         insert(&(*root)->left, pn);
  30.     }
  31. }
  33. //在二叉排序树t中删去关键字为k的结点
  34. void delete(struct Node** root, DataType k)
  35. {
  36.     struct Node* p, *f, *s, *q;
  37.     p=*root;
  38.     f=NULL;
  39.     while(p)//查找关键字为k的待删结点p
  40.     {
  41.         if(p->data==k )  break;  //找到则跳出循环
  42.         f=p;   //f指向p结点的双亲结点
  43.         if(p->data>k)
  44.             p=p->left;
  45.         else
  46.             p=p->right;
  47.     }
  48.     if(p==NULL)  return;  //若找不到，返回原来的二叉排序树
  49.     if(p->left==NULL)  //p无左子树
  50.     {
  51.         if(f==NULL)
  52.             *root=p->right;  //p是原二叉排序树的根
  53.         else if(f->left==p)  //p是f的左孩子
  54.             f->left=p->right;   //将p的右子树链到f的左链上
  55.         else  //p是f的右孩子
  56.             f->right=p->right;   //将p的右子树链到f的右链上
  57.         free(p);
  58.     }
  59.     else  //p有左子树
  60.     {
  61.         q=p;
  62.         s=p->left;
  63.         while(s->right)  //在p的左子树中查找最右下结点
  64.         {
  65.             q=s;
  66.             s=s->right;
  67.         }
  68.         if(q==p)
  69.             q->left=s->left;   //将s的左子树链到q上
  70.         else
  71.             q->right=s->left;
  72.         p->data=s->data;  //将s的值赋给p
  73.         free(s);
  74.     }
  75. }
  77. //查找一个树
  78. struct Node* find(struct Node* root, DataType d){
  79.     if(root == NULL)
  80.         return NULL;
  81.     if(d > root->data) //查找右子树
  82.         return find(root->right,d);
  83.     else if(d < root->data) //查找左子树
  84.         return find(root->left,d);
  85.     else
  86.         return root;
  87. }
  89. //修改树中结点的值
  90. void modify(struct Node* root, DataType oldData, DataType newData)
  91. {
  92.     struct Node* p;
  93.     p = find(root, oldData);
  94.     p->data = newData;
  95. }
  97. //清除一颗树
  98. void clears(struct Node **root) {
  99.     if (*root == NULL) return;
  100.     clears(&(*root)->left);
  101.     clears(&(*root)->right);
  102.     free(*root);
  103.     *root = NULL;
  104. }
  106. //打印一颗树
  107. void print(struct Node* root) {
  108.     if (root == NULL) return;
  109.     printf("%d ", root->data);
  110.     print(root->left);
  111.     print(root->right);
  112. }
  114. int main() {
  115.     
  116.     struct Node* root = NULL;
  117.     insert(&root, createNode(10));
  118.     insert(&root, createNode(5));
  119.     insert(&root, createNode(3));
  120.     insert(&root, createNode(2));
  121.     insert(&root, createNode(1));
  122.     insert(&root, createNode(4));
  123.     insert(&root, createNode(7));
  124.     insert(&root, createNode(6));
  125.     insert(&root, createNode(9));
  126.     insert(&root, createNode(8));
  127.     insert(&root, createNode(15));
  128.     print(root);
  129.     printf("\n");
  130.     
  131.     printf("%d\n", find(root, 5)->data);
  132.     
  133.     delete(&root, 10);
  134.     print(root);
  135.     return 0;
  136. }


















数据结构与算法--二叉树（一）

标签：

原文地址：http://blog.csdn.net/opera95/article/details/51216979
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！