zoukankan      html  css  js  c++  java
  • 二叉查找树

    二叉查找树

    总结:

    1、节点的定义中

    1 typedef int Type;
    2 
    3 typedef struct BSTreeNode{
    4     Type   key;                    // 关键字(键值)
    5     struct BSTreeNode *left;    // 左孩子
    6     struct BSTreeNode *right;    // 右孩子
    7     struct BSTreeNode *parent;    // 父结点
    8 }Node, *BSTree;

    a. 左右孩子用指针定义,类似于int *left,因为结构体本身就是一种自定义类型,struct BSTreeNode看成系统的类型int不过分。

    b. 用了typedef重定义类型,给struct BSTreeNode起了两个别名Node和*BSTree。

    c. 其中的*BSTree起始就相当于 typedef int *m中的*m。

    2、创建节点中

     1 static Node* create_bstree_node(Type key, Node *parent, Node *left, Node* right)
     2 {
     3     Node* p;
     4 
     5     if ((p = (Node *)malloc(sizeof(Node))) == NULL)
     6         return NULL;
     7     p->key = key;
     8     p->left = left;
     9     p->right = right;
    10     p->parent = parent;
    11 
    12     return p;
    13 }

    a. 用了malloc函数动态分配内存,p = (Node *)malloc(sizeof(Node)),很定式的写法,malloc出来的是指针,所以强转成指针,动态申请的空间大小,自然是sizeof(Node),Node是我们定义的结构体的别名

    b. if ((p = (Node *)malloc(sizeof(Node))) == NULL) 用动态分配的返回值是否为NULL来判断是否动态创建成功,c++的动态创建用的是new关键字。

    c. “没有”在C语言中表示为NULL,在JAVA中表示为null。

    d. 在c和c++中,对象是指针的话,用->来找成员,例如p->key = key;,如果对象是非指针的话,用的是.(点号)来找成员。

    3、在前序遍历中

    1 void preorder_bstree(BSTree tree)
    2 {
    3     if(tree != NULL)
    4     {
    5         printf("%d ", tree->key);
    6         preorder_bstree(tree->left);
    7         preorder_bstree(tree->right);
    8     }
    9 }

    a、非空的节点我们才有必要输出它的值和找左右孩子才有意义

    4、在递归查找中

    1 Node* bstree_search(BSTree x, Type key)
    2 {
    3     if (x==NULL || x->key==key)
    4         return x;
    5     if (key < x->key)
    6         return bstree_search(x->left, key);
    7     else
    8         return bstree_search(x->right, key);
    9 }

    要查的树的根节点是x,我们要查的键值是key,返回的节点是我们找到的那个值为key的节点,没找到返回NULL

    a. 第三行,空树就没有必要查了吧,这里也包括反复递归的过程中没有找到的而到NULL节点的情况,直接返回NULL就可以了,

    b. 如果找到key的话,直接返回那个节点即可

    c. 如果当前查找的key的值小于根的值,就往左子树跑,否则往右子树跑。递归调用。

    5、查找最大值的代码

    1 Node* bstree_maximum(BSTree tree)
    2 {
    3     if (tree == NULL)
    4         return NULL;
    5     while(tree->right != NULL)
    6         tree = tree->right;
    7     return tree;
    8 }

    要查找的是树的根节点tree,返回的是值最大的那个节点

    a. 如果树为空的话,直接返回即可。

    b. 如果右子树存在的情况下,也就是右子树不为空的情况就往右子树找。

    c. 找最小值和找最大值几乎一模一样,一个往左一个往右。

    6、查找前驱节点

    节点的前驱:是该节点的左子树中的最大节点。 

     1 Node* bstree_predecessor(Node *x)
     2 {
     3     // 如果x存在左孩子,则"x的前驱结点"为 "以其左孩子为根的子树的最大结点"。
     4     if (x->left != NULL)
     5         return bstree_maximum(x->left);
     6 
     7     // 如果x没有左孩子。则x有以下两种可能:
     8     // (01) x是"一个右孩子",则"x的前驱结点"为 "它的父结点"。
     9     // (01) x是"一个左孩子",则查找"x的最低的父结点,并且该父结点要具有右孩子",找到的这个"最低的父结点"就是"x的前驱结点"。
    10     Node* y = x->parent;
    11     while ((y!=NULL) && (x==y->left))
    12     {
    13         x = y;
    14         y = y->parent;
    15     }
    16 
    17     return y;
    18 }

    5这个节点有左孩子,所以前驱就是子树中的最大节点4.

    7这个节点没有左孩子且7是右孩子,所以前驱就是父亲节点6.

    2这个节点没有左孩子且2这个节点是左孩子,找到第一个父亲的祖先有右孩子的1就是它的前驱。同理节点8也是。

    a. 第一种情况用到了上面的求树中最大值的算法

    b. 节点y是x的父亲,去找父亲第一个有右孩子的祖先,就是x的前驱。因为走到节点5和1的时候发现5不是节点1的左孩子,就停止循环,故找到节点1.

    c. 第十行的那个代码包括第二种和第三种情况,比如找7(第二种情况)的前驱时候,把这段代码代进去算就会发现可以用。因为不是左孩子,没进循环,直接返回父亲了。

    7、查找后继节点

    节点的后继:是该节点的右子树中的最小节点。

     1 Node* bstree_successor(Node *x)
     2 {
     3     // 如果x存在右孩子,则"x的后继结点"为 "以其右孩子为根的子树的最小结点"。
     4     if (x->right != NULL)
     5         return bstree_minimum(x->right);
     6 
     7     // 如果x没有右孩子。则x有以下两种可能:
     8     // (01) x是"一个左孩子",则"x的后继结点"为 "它的父结点"。
     9     // (02) x是"一个右孩子",则查找"x的最低的父结点,并且该父结点要具有左孩子",找到的这个"最低的父结点"就是"x的后继结点"。
    10     Node* y = x->parent;
    11     while ((y!=NULL) && (x==y->right))
    12     {
    13         x = y;
    14         y = y->parent;
    15     }
    16 
    17     return y;
    18 }

    查找的是节点x的后继节点,返回的就是后继节点的那个点

    如果x存在右孩子,则"x的后继结点"为 "以其右孩子为根的子树的最小结点"。

    比如节点1的后继节点就是2

    如果x没有右孩子。则x有以下两种可能:
    (01) x是"一个左孩子",则"x的后继结点"为 "它的父结点"。

    比如说节点2,本身没有右孩子,自己又是左孩子,所以后继就是父亲,因为左子树总比根小
    (02) x是"一个右孩子",则查找"x的最低的父结点,并且该父结点要具有左孩子",找到的这个"最低的父结点"就是"x的后继结点"。

    比如说节点5,没有右孩子,自己又是右孩子,那就找父亲里面第一个有左孩子的就好,节点5的后继就是6.

    其实5没有右孩子,说明5是这颗子树里面最大的,而这样的结构只有变成左子树才能找到比它大的,所以找到的第一个左子树的分叉6就是后继。

    a. 代码第三行就是有右孩子直接右孩子那棵树返回最小的

    b. 第十行就是后面两种情况,去找左子树来找比它大的做它的后继,因为根比左子树大,都是找到第一个比它大的就是。

    8、插入节点

     1 static Node* bstree_insert(BSTree tree, Node *z)
     2 {
     3     Node *y = NULL;
     4     Node *x = tree;
     5 
     6     // 查找z的插入位置
     7     while (x != NULL)
     8     {
     9         y = x;
    10         if (z->key < x->key)
    11             x = x->left;
    12         else
    13             x = x->right;
    14     }
    15 
    16     z->parent = y;
    17     if (y==NULL)
    18         tree = z;
    19     else if (z->key < y->key)
    20         y->left = z;
    21     else
    22         y->right = z;
    23 
    24     return tree;
    25 }
    26 
    27 Node* insert_bstree(BSTree tree, Type key)
    28 {
    29     Node *z;    // 新建结点
    30 
    31     // 如果新建结点失败,则返回。
    32     if ((z=create_bstree_node(key, NULL, NULL, NULL)) == NULL)
    33         return tree;
    34 
    35     return bstree_insert(tree, z);
    36 }

    bstree_insert(tree, z)是内部函数,它的作用是:将结点(z)插入到二叉树(tree)中,并返回插入节点后的根节点。
    insert_bstree(tree, key)是对外接口,它的作用是:在树中新增节点,key是节点的值;并返回插入节点后的根节点。

    注:本文实现的二叉查找树是允许插入相同键值的节点的!

    insert_bstree(tree, key)中

    a. 32行的if ((z=create_bstree_node(key, NULL, NULL, NULL)) == NULL)是节点没有创建成功返回NULL

    b. 这里新建节点直接Node *z;,相当于int a;这样做是只声明了并没有给它内存空间,所以在create函数里面用了malloc给它内存空间。这里和JAVA一样。

    bstree_insert(tree, z)中

    a. 因为是在链上操作,所以插入操作需要需要记录两个点,把插入的点插到中间就好了,防止断链。

    b. 第6到14行代码,相等插在右子树上,6-14行就是找到那个为NULL的插入的位置

    c. 16-24行插入操作,如果树为空直接插入z做根节点,找到是插入左边还是右边,因为节点是插入在y的子树上的,这里的y是插入位置的父亲

    9、删除操作

    二叉树的删除可以算是二叉树最为复杂的操作,删除的时候要考虑到很多种情况:
    1.被删除的节点是叶子节点
    2.被删除的节点只有左孩子节点
    3.被删除的节点只有右孩子节点
    4.被删除的有两个孩子节点
    所以在删除的时候,这4种情况都必须考虑进去,并且这4中情况之下,还会有细的划分,下面就细说怎么删除。

    bstree_delete(tree, z)是内部函数,它的作用是:删除二叉树(tree)中的节点(z),并返回删除节点后的根节点。
    delete_bstree(tree, key)是对外接口,它的作用是:在树中查找键值为key的节点,找到的话就删除该节点;并返回删除节点后的根节点。

     1 //tree是树的根节点,z是我们要删除的那个节点 
     2 static Node* bstree_delete(BSTree tree, Node *z)
     3 {
     4     Node *x=NULL;
     5     Node *y=NULL;
     6     
     7     //左孩子或者右孩子为空的情况,就是只有一个孩子或者两个孩子都没有的情况 
     8     //直接将z赋值给y 
     9     if ((z->left == NULL) || (z->right == NULL) )
    10         y = z;
    11     else//两个孩子都存在的情况下,直接找z的后继 
    12         y = bstree_successor(z);
    13 
    14     //那个后继节点的左子树不为空,将左子树给x 
    15     if (y->left != NULL)
    16         x = y->left;
    17     else//那个后继节点的左子树为空的话,那x就是y的右子树 
    18         x = y->right;
    19 
    20     //x节点不为空的情况,将y的父亲赋值给x的父亲,标准的删除操作,这是为了删除后继节点y
    21     //因为删除的思路就是用后继节点来替换删除的那个节点 
    22     if (x != NULL)
    23         x->parent = y->parent;
    24 
    25     //如果y没有父亲了,y是比较靠近树根的点 
    26     if (y->parent == NULL)
    27         tree = x;
    28     else if (y == y->parent->left)
    29         y->parent->left = x;
    30     else
    31         y->parent->right = x;
    32 
    33     if (y != z) 
    34         z->key = y->key;
    35 
    36     if (y!=NULL)
    37         free(y);
    38 
    39     return tree;
    40 }
    41 
    42 Node* delete_bstree(BSTree tree, Type key)
    43 {
    44     Node *z, *node; 
    45 
    46     if ((z = bstree_search(tree, key)) != NULL)
    47         tree = bstree_delete(tree, z);
    48 
    49     return tree;
    50 }

    在delete_bstree(tree, key)中

    a. 先调用查找函数找这个节点,如果找到了就删了这个节点,z是这个找到的节点

    在bstree_delete(tree, z)中

    a. 第9行的y = bstree_successor(z);是找到z的后继y,

    10、打印二叉树

     1 void print_bstree(BSTree tree, Type key, int direction)
     2 {
     3     if(tree != NULL)
     4     {
     5         if(direction==0)    // tree是根节点
     6             printf("%2d is root
    ", tree->key);
     7         else                // tree是分支节点
     8             printf("%2d is %2d's %6s child
    ", tree->key, key, direction==1?"right" : "left");
     9 
    10         print_bstree(tree->left, tree->key, -1);
    11         print_bstree(tree->right,tree->key,  1);
    12     }
    13 }

    print_bstree(tree, key, direction)的作用是打印整颗二叉树(tree)。其中,tree是二叉树节点,key是二叉树的键值,而direction表示该节点的类型:

    direction为 0,表示该节点是根节点;
    direction为-1,表示该节点是它的父结点的左孩子;
    direction为 1,表示该节点是它的父结点的右孩子。

    a. 这样子用一个 中间变量direction可以指明每一个点是左还是右还是根。

    11、 销毁二叉树

     1 void destroy_bstree(BSTree tree)
     2 {
     3     if (tree==NULL)
     4         return ;
     5 
     6     if (tree->left != NULL)
     7         destroy_bstree(tree->left);
     8     if (tree->right != NULL)
     9         destroy_bstree(tree->right);
    10 
    11     free(tree);
    12 }

    a. 如果tree为空,不用销毁,在销毁了左右之后再来销毁根

    b. 销毁的核心操作就是free,这个操作是释放指针所指的内存空间,按JAVA里面的说法就是释放堆空间,因为栈空间系统会自动维护的,虽然JAVA里面没有指针,但是引用本质也是指针。

    概要

           本章先对二叉树的相关理论知识进行介绍,然后给出C语言的详细实现。关于二叉树的学习,需要说明的是:它并不难,不仅不难,而且它非常简单。初次接触树的时候,我也觉得它似乎很难;而之所产生这种感觉主要是由于二叉树有一大堆陌生的概念、性质等内容。而当我真正的实现了二叉树再回过头来看它的相关概念和性质的时候,觉得原来它是如此的简单!因此,建议在学习二叉树的时候:先对二叉树基本的概念、性质有个基本了解,遇到难懂的知识点,可以画图来帮助理解;在有个基本的概念之后,再亲自动手实现二叉查找树(这一点至关重要!);最后再回过头来总结一下二叉树的理论知识时,你会发现——它的确很简单!在代码实践中,我以"二叉查找树,而不是单纯的二叉树"为例子进行说明,单纯的二叉树非常简单,实际使用很少。况且掌握了二叉查找树,二叉树也就自然掌握了。

          本篇实现的二叉查找树是C语言版的,后面章节再分别给出C++和Java版本的实现。您可以根据自己熟悉的语言进行实践学习!

          请务必深刻理解、实践并掌握"二叉查找树"!它是后面学习AVL树、伸展树、红黑树等相关树结构的基石!

    目录
    1. 树的介绍
    2. 二叉树的介绍
    3. 二叉查找树的C实现
    4. 二叉查找树的C测试程序

    转载请注明出处:http://www.cnblogs.com/skywang12345/p/3576328.html


    更多内容数据结构与算法系列 目录 

    (01). 二叉查找树(一)之 图文解析 和 C语言的实现
    (02). 二叉查找树(二)之 C++的实现
    (03). 二叉查找树(三)之 Java的实现

    树的介绍

    1. 树的定义

    树是一种数据结构,它是由n(n>=1)个有限节点组成一个具有层次关系的集合。

    把它叫做“树”是因为它看起来像一棵倒挂的树,也就是说它是根朝上,而叶朝下的。它具有以下的特点:
    (01) 每个节点有零个或多个子节点;
    (02) 没有父节点的节点称为根节点;
    (03) 每一个非根节点有且只有一个父节点;
    (04) 除了根节点外,每个子节点可以分为多个不相交的子树。

    2. 树的基本术语

    若一个结点有子树,那么该结点称为子树根的"双亲",子树的根是该结点的"孩子"。有相同双亲的结点互为"兄弟"。一个结点的所有子树上的任何结点都是该结点的后裔。从根结点到某个结点的路径上的所有结点都是该结点的祖先。

    结点的度:结点拥有的子树的数目。
    叶子:度为零的结点。
    分支结点:度不为零的结点。
    树的度:树中结点的最大的度。

    层次:根结点的层次为1,其余结点的层次等于该结点的双亲结点的层次加1。
    树的高度:树中结点的最大层次。
    无序树:如果树中结点的各子树之间的次序是不重要的,可以交换位置。
    有序树:如果树中结点的各子树之间的次序是重要的, 不可以交换位置。
    森林:0个或多个不相交的树组成。对森林加上一个根,森林即成为树;删去根,树即成为森林。

    二叉树的介绍

    1. 二叉树的定义

    二叉树是每个节点最多有两个子树的树结构。它有五种基本形态:二叉树可以是空集;根可以有空的左子树或右子树;或者左、右子树皆为空。

    2. 二叉树的性质

    二叉树有以下几个性质:TODO(上标和下标)
    性质1:二叉树第i层上的结点数目最多为 2{i-1} (i≥1)。
    性质2:深度为k的二叉树至多有2{k}-1个结点(k≥1)。
    性质3:包含n个结点的二叉树的高度至少为log2 (n+1)
    性质4:在任意一棵二叉树中,若终端结点的个数为n0,度为2的结点数为n2,则n0=n2+1

    2.1 性质1:二叉树第i层上的结点数目最多为 2{i-1} (i≥1)

    证明:下面用"数学归纳法"进行证明。
            (01) 当i=1时,第i层的节点数目为2{i-1}=2{0}=1。因为第1层上只有一个根结点,所以命题成立。
            (02) 假设当i>1,第i层的节点数目为2{i-1}。这个是根据(01)推断出来的!
                   下面根据这个假设,推断出"第(i+1)层的节点数目为2{i}"即可。
                    由于二叉树的每个结点至多有两个孩子,故"第(i+1)层上的结点数目" 最多是 "第i层的结点数目的2倍"。即,第(i+1)层上的结点数目最大值=2×2{i-1}=2{i}
                    故假设成立,原命题得证!

    2.2 性质2:深度为k的二叉树至多有2{k}-1个结点(k≥1)

    证明:在具有相同深度的二叉树中,当每一层都含有最大结点数时,其树中结点数最多。利用"性质1"可知,深度为k的二叉树的结点数至多为:
               20+21+…+2k-1=2k-1
               故原命题得证!

    2.3 性质3:包含n个结点的二叉树的高度至少为log2 (n+1)

    证明:根据"性质2"可知,高度为h的二叉树最多有2{h}–1个结点。反之,对于包含n个节点的二叉树的高度至少为log2(n+1)。

    2.4 性质4:在任意一棵二叉树中,若终端结点的个数为n0,度为2的结点数为n2,则n0=n2+1

    证明:因为二叉树中所有结点的度数均不大于2,所以结点总数(记为n)="0度结点数(n0)" + "1度结点数(n1)" + "2度结点数(n2)"。由此,得到等式一。
             (等式一) n=n0+n1+n2
          另一方面,0度结点没有孩子,1度结点有一个孩子,2度结点有两个孩子,故二叉树中孩子结点总数是:n1+2n2。此外,只有根不是任何结点的孩子。故二叉树中的结点总数又可表示为等式二。
             (等式二) n=n1+2n2+1
            由(等式一)和(等式二)计算得到:n0=n2+1。原命题得证!

    3. 满二叉树,完全二叉树和二叉查找树

    3.1 满二叉树

    定义:高度为h,并且由2{h} –1个结点的二叉树,被称为满二叉树。

    3.2 完全二叉树

    定义:一棵二叉树中,只有最下面两层结点的度可以小于2,并且最下一层的叶结点集中在靠左的若干位置上。这样的二叉树称为完全二叉树。
    特点:叶子结点只能出现在最下层和次下层,且最下层的叶子结点集中在树的左部。显然,一棵满二叉树必定是一棵完全二叉树,而完全二叉树未必是满二叉树。

    3.3 二叉查找树

    定义:二叉查找树(Binary Search Tree),又被称为二叉搜索树。设x为二叉查找树中的一个结点,x节点包含关键字key,节点x的key值记为key[x]。如果y是x的左子树中的一个结点,则key[y] <= key[x];如果y是x的右子树的一个结点,则key[y] >= key[x]。

    在二叉查找树中:
    (01) 若任意节点的左子树不空,则左子树上所有结点的值均小于它的根结点的值;
    (02) 任意节点的右子树不空,则右子树上所有结点的值均大于它的根结点的值;
    (03) 任意节点的左、右子树也分别为二叉查找树。
    (04) 没有键值相等的节点(no duplicate nodes)。

    在实际应用中,二叉查找树的使用比较多。下面,用C语言实现二叉查找树。

    二叉查找树的C实现

    1. 节点定义

    1.1 节点定义

    复制代码
    typedef int Type;
    
    typedef struct BSTreeNode{
        Type   key;                    // 关键字(键值)
        struct BSTreeNode *left;    // 左孩子
        struct BSTreeNode *right;    // 右孩子
        struct BSTreeNode *parent;    // 父结点
    }Node, *BSTree;
    复制代码

    二叉查找树的节点包含的基本信息:
    (01) key       -- 它是关键字,是用来对二叉查找树的节点进行排序的。
    (02) left       -- 它指向当前节点的左孩子。
    (03) right    -- 它指向当前节点的右孩子。
    (04) parent -- 它指向当前节点的父结点。

    1.2 创建节点

    创建节点的代码

    复制代码
    static Node* create_bstree_node(Type key, Node *parent, Node *left, Node* right)
    {
        Node* p;
    
        if ((p = (Node *)malloc(sizeof(Node))) == NULL)
            return NULL;
        p->key = key;
        p->left = left;
        p->right = right;
        p->parent = parent;
    
        return p;
    }
    复制代码

    2 遍历

    这里讲解前序遍历中序遍历后序遍历3种方式。

    2.1 前序遍历

    若二叉树非空,则执行以下操作:
    (01) 访问根结点;
    (02) 先序遍历左子树;
    (03) 先序遍历右子树。

    前序遍历代码

    复制代码
    void preorder_bstree(BSTree tree)
    {
        if(tree != NULL)
        {
            printf("%d ", tree->key);
            preorder_bstree(tree->left);
            preorder_bstree(tree->right);
        }
    }
    复制代码

    2.2 中序遍历

    若二叉树非空,则执行以下操作:
    (01) 中序遍历左子树;
    (02) 访问根结点;
    (03) 中序遍历右子树。

    中序遍历代码

    复制代码
    void inorder_bstree(BSTree tree)
    {
        if(tree != NULL)
        {
            inorder_bstree(tree->left);
            printf("%d ", tree->key);
            inorder_bstree(tree->right);
        }
    }
    复制代码

    2.3 后序遍历

    若二叉树非空,则执行以下操作:
    (01) 后序遍历左子树;
    (02) 后序遍历右子树;
    (03) 访问根结点。

    后序遍历代码

    复制代码
    void postorder_bstree(BSTree tree)
    {
        if(tree != NULL)
        {
            postorder_bstree(tree->left);
            postorder_bstree(tree->right);
            printf("%d ", tree->key);
        }
    }
    复制代码

    下面通过例子对这些遍历方式进行介绍。

    对于上面的二叉树而言,
    (01) 前序遍历结果: 3 1 2 5 4 6
    (02) 中序遍历结果: 1 2 3 4 5 6 
    (03) 后序遍历结果: 2 1 4 6 5 3

    3. 查找

    递归版本的代码

    复制代码
    Node* bstree_search(BSTree x, Type key)
    {
        if (x==NULL || x->key==key)
            return x;
    
        if (key < x->key)
            return bstree_search(x->left, key);
        else
            return bstree_search(x->right, key);
    }
    复制代码

    非递归版本的代码

    复制代码
    Node* iterative_bstree_search(BSTree x, Type key)
    {
        while ((x!=NULL) && (x->key!=key))
        {
            if (key < x->key)
                x = x->left;
            else
                x = x->right;
        }
    
        return x;
    }
    复制代码

    4. 最大值和最小值

    查找最大值的代码

    复制代码
    Node* bstree_maximum(BSTree tree)
    {
        if (tree == NULL)
            return NULL;
    
        while(tree->right != NULL)
            tree = tree->right;
        return tree;
    }
    复制代码

    查找最小值的代码

    复制代码
    Node* bstree_minimum(BSTree tree)
    {
        if (tree == NULL)
            return NULL;
    
        while(tree->left != NULL)
            tree = tree->left;
        return tree;
    }
    复制代码


    5. 前驱和后继

    节点的前驱:是该节点的左子树中的最大节点。
    节点的后继:是该节点的右子树中的最小节点。

    查找前驱节点的代码

    复制代码
    Node* bstree_predecessor(Node *x)
    {
        // 如果x存在左孩子,则"x的前驱结点"为 "以其左孩子为根的子树的最大结点"。
        if (x->left != NULL)
            return bstree_maximum(x->left);
    
        // 如果x没有左孩子。则x有以下两种可能:
        // (01) x是"一个右孩子",则"x的前驱结点"为 "它的父结点"。
        // (01) x是"一个左孩子",则查找"x的最低的父结点,并且该父结点要具有右孩子",找到的这个"最低的父结点"就是"x的前驱结点"。
        Node* y = x->parent;
        while ((y!=NULL) && (x==y->left))
        {
            x = y;
            y = y->parent;
        }
    
        return y;
    }
    复制代码

    查找后继节点的代码

    复制代码
    Node* bstree_successor(Node *x)
    {
        // 如果x存在右孩子,则"x的后继结点"为 "以其右孩子为根的子树的最小结点"。
        if (x->right != NULL)
            return bstree_minimum(x->right);
    
        // 如果x没有右孩子。则x有以下两种可能:
        // (01) x是"一个左孩子",则"x的后继结点"为 "它的父结点"。
        // (02) x是"一个右孩子",则查找"x的最低的父结点,并且该父结点要具有左孩子",找到的这个"最低的父结点"就是"x的后继结点"。
        Node* y = x->parent;
        while ((y!=NULL) && (x==y->right))
        {
            x = y;
            y = y->parent;
        }
    
        return y;
    }
    复制代码

    6. 插入

    插入节点的代码

    复制代码
    static Node* bstree_insert(BSTree tree, Node *z)
    {
        Node *y = NULL;
        Node *x = tree;
    
        // 查找z的插入位置
        while (x != NULL)
        {
            y = x;
            if (z->key < x->key)
                x = x->left;
            else
                x = x->right;
        }
    
        z->parent = y;
        if (y==NULL)
            tree = z;
        else if (z->key < y->key)
            y->left = z;
        else
            y->right = z;
    
        return tree;
    }
    
    Node* insert_bstree(BSTree tree, Type key)
    {
        Node *z;    // 新建结点
    
        // 如果新建结点失败,则返回。
        if ((z=create_bstree_node(key, NULL, NULL, NULL)) == NULL)
            return tree;
    
        return bstree_insert(tree, z);
    }
    复制代码

    bstree_insert(tree, z)是内部函数,它的作用是:将结点(z)插入到二叉树(tree)中,并返回插入节点后的根节点。
    insert_bstree(tree, key)是对外接口,它的作用是:在树中新增节点,key是节点的值;并返回插入节点后的根节点。

    注:本文实现的二叉查找树是允许插入相同键值的节点的!若用户不希望插入相同键值的节点,将bstree_insert()修改为以下代码即可。

    复制代码
    static Node* bstree_insert(BSTree tree, Node *z)
    {
        Node *y = NULL;
        Node *x = tree;
    
        // 查找z的插入位置
        while (x != NULL)
        {
            y = x;
            if (z->key < x->key)
                x = x->left;
            else  if (z->key > x->key)
                x = x->right;
            else
            {
                free(z); // 释放之前分配的系统。
                return tree;
            }
        }
    
        z->parent = y;
        if (y==NULL)
            tree = z;
        else if (z->key < y->key)
            y->left = z;
        else
            y->right = z;
    
        return tree;
    }
    复制代码

    7. 删除

    删除节点的代码

    复制代码
    static Node* bstree_delete(BSTree tree, Node *z)
    {
        Node *x=NULL;
        Node *y=NULL;
    
        if ((z->left == NULL) || (z->right == NULL) )
            y = z;
        else
            y = bstree_successor(z);
    
        if (y->left != NULL)
            x = y->left;
        else
            x = y->right;
    
        if (x != NULL)
            x->parent = y->parent;
    
        if (y->parent == NULL)
            tree = x;
        else if (y == y->parent->left)
            y->parent->left = x;
        else
            y->parent->right = x;
    
        if (y != z) 
            z->key = y->key;
    
        if (y!=NULL)
            free(y);
    
        return tree;
    }
    
    Node* delete_bstree(BSTree tree, Type key)
    {
        Node *z, *node; 
    
        if ((z = bstree_search(tree, key)) != NULL)
            tree = bstree_delete(tree, z);
    
        return tree;
    }
    复制代码

    bstree_delete(tree, z)是内部函数,它的作用是:删除二叉树(tree)中的节点(z),并返回删除节点后的根节点。
    delete_bstree(tree, key)是对外接口,它的作用是:在树中查找键值为key的节点,找到的话就删除该节点;并返回删除节点后的根节点。


    8. 打印

    打印二叉树的代码

    复制代码
    void print_bstree(BSTree tree, Type key, int direction)
    {
        if(tree != NULL)
        {
            if(direction==0)    // tree是根节点
                printf("%2d is root
    ", tree->key);
            else                // tree是分支节点
                printf("%2d is %2d's %6s child
    ", tree->key, key, direction==1?"right" : "left");
    
            print_bstree(tree->left, tree->key, -1);
            print_bstree(tree->right,tree->key,  1);
        }
    }
    复制代码

    print_bstree(tree, key, direction)的作用是打印整颗二叉树(tree)。其中,tree是二叉树节点,key是二叉树的键值,而direction表示该节点的类型:

    direction为 0,表示该节点是根节点;
    direction为-1,表示该节点是它的父结点的左孩子;
    direction为 1,表示该节点是它的父结点的右孩子。

    9. 销毁二叉树

    销毁二叉树的代码

    复制代码
    void destroy_bstree(BSTree tree)
    {
        if (tree==NULL)
            return ;
    
        if (tree->left != NULL)
            destroy_bstree(tree->left);
        if (tree->right != NULL)
            destroy_bstree(tree->right);
    
        free(tree);
    }
    复制代码

    完整的实现代码

    二叉查找树的头文件(bstree.h)

    复制代码
     1 #ifndef _BINARY_SEARCH_TREE_H_
     2 #define _BINARY_SEARCH_TREE_H_
     3 
     4 typedef int Type;
     5 
     6 typedef struct BSTreeNode{
     7     Type   key;                    // 关键字(键值)
     8     struct BSTreeNode *left;    // 左孩子
     9     struct BSTreeNode *right;    // 右孩子
    10     struct BSTreeNode *parent;    // 父结点
    11 }Node, *BSTree;
    12 
    13 // 前序遍历"二叉树"
    14 void preorder_bstree(BSTree tree);
    15 // 中序遍历"二叉树"
    16 void inorder_bstree(BSTree tree);
    17 // 后序遍历"二叉树"
    18 void postorder_bstree(BSTree tree);
    19 
    20 // (递归实现)查找"二叉树x"中键值为key的节点
    21 Node* bstree_search(BSTree x, Type key);
    22 // (非递归实现)查找"二叉树x"中键值为key的节点
    23 Node* iterative_bstree_search(BSTree x, Type key);
    24 
    25 // 查找最小结点:返回tree为根结点的二叉树的最小结点。
    26 Node* bstree_minimum(BSTree tree);
    27 // 查找最大结点:返回tree为根结点的二叉树的最大结点。
    28 Node* bstree_maximum(BSTree tree);
    29 
    30 // 找结点(x)的后继结点。即,查找"二叉树中数据值大于该结点"的"最小结点"。
    31 Node* bstree_successor(Node *x);
    32 // 找结点(x)的前驱结点。即,查找"二叉树中数据值小于该结点"的"最大结点"。
    33 Node* bstree_predecessor(Node *x);
    34 
    35 // 将结点插入到二叉树中,并返回根节点
    36 Node* insert_bstree(BSTree tree, Type key);
    37 
    38 // 删除结点(key为节点的值),并返回根节点
    39 Node* delete_bstree(BSTree tree, Type key);
    40 
    41 // 销毁二叉树
    42 void destroy_bstree(BSTree tree);
    43 
    44 // 打印二叉树
    45 void print_bstree(BSTree tree, Type key, int direction);
    46 
    47 #endif
    复制代码

    二叉查找树的实现文件(bstree.c)

    复制代码
      1 /**
      2  * 二叉搜索树(C语言): C语言实现的二叉搜索树。
      3  *
      4  * @author skywang
      5  * @date 2013/11/07
      6  */
      7 
      8 #include <stdio.h>
      9 #include <stdlib.h>
     10 #include "bstree.h"
     11 
     12 
     13 /*
     14  * 前序遍历"二叉树"
     15  */
     16 void preorder_bstree(BSTree tree)
     17 {
     18     if(tree != NULL)
     19     {
     20         printf("%d ", tree->key);
     21         preorder_bstree(tree->left);
     22         preorder_bstree(tree->right);
     23     }
     24 }
     25 
     26 /*
     27  * 中序遍历"二叉树"
     28  */
     29 void inorder_bstree(BSTree tree)
     30 {
     31     if(tree != NULL)
     32     {
     33         inorder_bstree(tree->left);
     34         printf("%d ", tree->key);
     35         inorder_bstree(tree->right);
     36     }
     37 }
     38 
     39 /*
     40  * 后序遍历"二叉树"
     41  */
     42 void postorder_bstree(BSTree tree)
     43 {
     44     if(tree != NULL)
     45     {
     46         postorder_bstree(tree->left);
     47         postorder_bstree(tree->right);
     48         printf("%d ", tree->key);
     49     }
     50 }
     51 
     52 /*
     53  * (递归实现)查找"二叉树x"中键值为key的节点
     54  */
     55 Node* bstree_search(BSTree x, Type key)
     56 {
     57     if (x==NULL || x->key==key)
     58         return x;
     59 
     60     if (key < x->key)
     61         return bstree_search(x->left, key);
     62     else
     63         return bstree_search(x->right, key);
     64 }
     65 
     66 /*
     67  * (非递归实现)查找"二叉树x"中键值为key的节点
     68  */
     69 Node* iterative_bstree_search(BSTree x, Type key)
     70 {
     71     while ((x!=NULL) && (x->key!=key))
     72     {
     73         if (key < x->key)
     74             x = x->left;
     75         else
     76             x = x->right;
     77     }
     78 
     79     return x;
     80 }
     81 
     82 /* 
     83  * 查找最小结点:返回tree为根结点的二叉树的最小结点。
     84  */
     85 Node* bstree_minimum(BSTree tree)
     86 {
     87     if (tree == NULL)
     88         return NULL;
     89 
     90     while(tree->left != NULL)
     91         tree = tree->left;
     92     return tree;
     93 }
     94  
     95 /* 
     96  * 查找最大结点:返回tree为根结点的二叉树的最大结点。
     97  */
     98 Node* bstree_maximum(BSTree tree)
     99 {
    100     if (tree == NULL)
    101         return NULL;
    102 
    103     while(tree->right != NULL)
    104         tree = tree->right;
    105     return tree;
    106 }
    107 
    108 /* 
    109  * 找结点(x)的后继结点。即,查找"二叉树中数据值大于该结点"的"最小结点"。
    110  */
    111 Node* bstree_successor(Node *x)
    112 {
    113     // 如果x存在右孩子,则"x的后继结点"为 "以其右孩子为根的子树的最小结点"。
    114     if (x->right != NULL)
    115         return bstree_minimum(x->right);
    116 
    117     // 如果x没有右孩子。则x有以下两种可能:
    118     // (01) x是"一个左孩子",则"x的后继结点"为 "它的父结点"。
    119     // (02) x是"一个右孩子",则查找"x的最低的父结点,并且该父结点要具有左孩子",找到的这个"最低的父结点"就是"x的后继结点"。
    120     Node* y = x->parent;
    121     while ((y!=NULL) && (x==y->right))
    122     {
    123         x = y;
    124         y = y->parent;
    125     }
    126 
    127     return y;
    128 }
    129  
    130 /* 
    131  * 找结点(x)的前驱结点。即,查找"二叉树中数据值小于该结点"的"最大结点"。
    132  */
    133 Node* bstree_predecessor(Node *x)
    134 {
    135     // 如果x存在左孩子,则"x的前驱结点"为 "以其左孩子为根的子树的最大结点"。
    136     if (x->left != NULL)
    137         return bstree_maximum(x->left);
    138 
    139     // 如果x没有左孩子。则x有以下两种可能:
    140     // (01) x是"一个右孩子",则"x的前驱结点"为 "它的父结点"。
    141     // (01) x是"一个左孩子",则查找"x的最低的父结点,并且该父结点要具有右孩子",找到的这个"最低的父结点"就是"x的前驱结点"。
    142     Node* y = x->parent;
    143     while ((y!=NULL) && (x==y->left))
    144     {
    145         x = y;
    146         y = y->parent;
    147     }
    148 
    149     return y;
    150 }
    151 
    152 /*
    153  * 创建并返回二叉树结点。
    154  *
    155  * 参数说明:
    156  *     key 是键值。
    157  *     parent 是父结点。
    158  *     left 是左孩子。
    159  *     right 是右孩子。
    160  */
    161 static Node* create_bstree_node(Type key, Node *parent, Node *left, Node* right)
    162 {
    163     Node* p;
    164 
    165     if ((p = (Node *)malloc(sizeof(Node))) == NULL)
    166         return NULL;
    167     p->key = key;
    168     p->left = left;
    169     p->right = right;
    170     p->parent = parent;
    171 
    172     return p;
    173 }
    174 
    175 /* 
    176  * 将结点插入到二叉树中
    177  *
    178  * 参数说明:
    179  *     tree 二叉树的根结点
    180  *     z 插入的结点
    181  * 返回值:
    182  *     根节点
    183  */
    184 static Node* bstree_insert(BSTree tree, Node *z)
    185 {
    186     Node *y = NULL;
    187     Node *x = tree;
    188 
    189     // 查找z的插入位置
    190     while (x != NULL)
    191     {
    192         y = x;
    193         if (z->key < x->key)
    194             x = x->left;
    195         else
    196             x = x->right;
    197     }
    198 
    199     z->parent = y;
    200     if (y==NULL)
    201         tree = z;
    202     else if (z->key < y->key)
    203         y->left = z;
    204     else
    205         y->right = z;
    206 
    207     return tree;
    208 }
    209 
    210 /* 
    211  * 新建结点(key),并将其插入到二叉树中
    212  *
    213  * 参数说明:
    214  *     tree 二叉树的根结点
    215  *     key 插入结点的键值
    216  * 返回值:
    217  *     根节点
    218  */
    219 Node* insert_bstree(BSTree tree, Type key)
    220 {
    221     Node *z;    // 新建结点
    222 
    223     // 如果新建结点失败,则返回。
    224     if ((z=create_bstree_node(key, NULL, NULL, NULL)) == NULL)
    225         return tree;
    226 
    227     return bstree_insert(tree, z);
    228 }
    229 
    230 /* 
    231  * 删除结点(z),并返回根节点
    232  *
    233  * 参数说明:
    234  *     tree 二叉树的根结点
    235  *     z 删除的结点
    236  * 返回值:
    237  *     根节点
    238  */
    239 static Node* bstree_delete(BSTree tree, Node *z)
    240 {
    241     Node *x=NULL;
    242     Node *y=NULL;
    243 
    244     if ((z->left == NULL) || (z->right == NULL) )
    245         y = z;
    246     else
    247         y = bstree_successor(z);
    248 
    249     if (y->left != NULL)
    250         x = y->left;
    251     else
    252         x = y->right;
    253 
    254     if (x != NULL)
    255         x->parent = y->parent;
    256 
    257     if (y->parent == NULL)
    258         tree = x;
    259     else if (y == y->parent->left)
    260         y->parent->left = x;
    261     else
    262         y->parent->right = x;
    263 
    264     if (y != z) 
    265         z->key = y->key;
    266 
    267     if (y!=NULL)
    268         free(y);
    269 
    270     return tree;
    271 }
    272 
    273 /* 
    274  * 删除结点(key为节点的键值),并返回根节点
    275  *
    276  * 参数说明:
    277  *     tree 二叉树的根结点
    278  *     z 删除的结点
    279  * 返回值:
    280  *     根节点
    281  */
    282 Node* delete_bstree(BSTree tree, Type key)
    283 {
    284     Node *z, *node; 
    285 
    286     if ((z = bstree_search(tree, key)) != NULL)
    287         tree = bstree_delete(tree, z);
    288 
    289     return tree;
    290 }
    291 
    292 /*
    293  * 销毁二叉树
    294  */
    295 void destroy_bstree(BSTree tree)
    296 {
    297     if (tree==NULL)
    298         return ;
    299 
    300     if (tree->left != NULL)
    301         destroy_bstree(tree->left);
    302     if (tree->right != NULL)
    303         destroy_bstree(tree->right);
    304 
    305     free(tree);
    306 }
    307 
    308 /*
    309  * 打印"二叉树"
    310  *
    311  * tree       -- 二叉树的节点
    312  * key        -- 节点的键值 
    313  * direction  --  0,表示该节点是根节点;
    314  *               -1,表示该节点是它的父结点的左孩子;
    315  *                1,表示该节点是它的父结点的右孩子。
    316  */
    317 void print_bstree(BSTree tree, Type key, int direction)
    318 {
    319     if(tree != NULL)
    320     {
    321         if(direction==0)    // tree是根节点
    322             printf("%2d is root
    ", tree->key);
    323         else                // tree是分支节点
    324             printf("%2d is %2d's %6s child
    ", tree->key, key, direction==1?"right" : "left");
    325 
    326         print_bstree(tree->left, tree->key, -1);
    327         print_bstree(tree->right,tree->key,  1);
    328     }
    329 }
    复制代码

    二叉查找树的测试程序(btree_test.c)

    复制代码
     1 /**
     2  * C 语言: 二叉查找树
     3  *
     4  * @author skywang
     5  * @date 2013/11/07
     6  */
     7 
     8 #include <stdio.h>
     9 #include "bstree.h"
    10 
    11 static int arr[]= {1,5,4,3,2,6};
    12 #define TBL_SIZE(a) ( (sizeof(a)) / (sizeof(a[0])) )
    13 
    14 void main()
    15 {
    16     int i, ilen;
    17     BSTree root=NULL;
    18 
    19     printf("== 依次添加: ");
    20     ilen = TBL_SIZE(arr);
    21     for(i=0; i<ilen; i++)
    22     {
    23         printf("%d ", arr[i]);
    24         root = insert_bstree(root, arr[i]);
    25     }
    26 
    27     printf("
    == 前序遍历: ");
    28     preorder_bstree(root);
    29 
    30     printf("
    == 中序遍历: ");
    31     inorder_bstree(root);
    32 
    33     printf("
    == 后序遍历: ");
    34     postorder_bstree(root);
    35     printf("
    ");
    36 
    37     printf("== 最小值: %d
    ", bstree_minimum(root)->key);
    38     printf("== 最大值: %d
    ", bstree_maximum(root)->key);
    39     printf("== 树的详细信息: 
    ");
    40     print_bstree(root, root->key, 0);
    41 
    42     printf("
    == 删除根节点: %d", arr[3]);
    43     root = delete_bstree(root, arr[3]);
    44 
    45     printf("
    == 中序遍历: ");
    46     inorder_bstree(root);
    47     printf("
    ");
    48 
    49     // 销毁二叉树
    50     destroy_bstree(root);
    51 }
    复制代码

    二叉查找树的C测试程序

    上面的btree_test.c是二叉查找树的测试程序,它的运行结果如下:

    复制代码
    == 依次添加: 1 5 4 3 2 6 
    == 前序遍历: 1 5 4 3 2 6 
    == 中序遍历: 1 2 3 4 5 6 
    == 后序遍历: 2 3 4 6 5 1 
    == 最小值: 1
    == 最大值: 6
    == 树的详细信息: 
     1 is root
     5 is  1's  right child
     4 is  5's   left child
     3 is  4's   left child
     2 is  3's   left child
     6 is  5's  right child
    
    == 删除根节点: 3
    == 中序遍历: 1 2 4 5 6 
    复制代码

    下面对测试程序的流程进行分析!

    (01) 新建"二叉查找树"root。

    (02) 向二叉查找树中依次插入1,5,4,3,2,6 。如下图所示:

    (03) 打印树的信息
    插入1,5,4,3,2,6之后,得到的二叉查找树如下:

    前序遍历结果: 1 5 4 3 2 6 
    中序遍历结果: 1 2 3 4 5 6 
    后序遍历结果: 2 3 4 6 5 1 
    最小值是1,而最大值是6。

    (04) 删除节点3。如下图所示:

    (05) 重新遍历该二叉查找树。
    中序遍历结果: 1 2 4 5 6

  • 相关阅读:
    自动化基础知识
    第一章Google软件测试介绍
    《将博客搬至CSDN》
    二叉树的先序遍历和中序遍历分析(递归)
    java 部分快捷功能
    toString
    自增自减运算符剖析
    二进制数的直接表示
    编程中的&&和||
    npm 镜像地址设置
  • 原文地址:https://www.cnblogs.com/Renyi-Fan/p/8185325.html
Copyright © 2011-2022 走看看