请问一个关于 二叉排序树的问题

Posted 2023-02-15

从空树开始，依次插入元素55，22，63，47，98，13，71，90，34和85后构成了一棵二叉排序树。在该树查找71要进行比较次数为？
望各位达人帮我解决，最好有过程，还有 那个树的形态，谢谢

树的形态如下:(百度不让空格,将就着看吧-_-)
1层：55(左是22,右63)
2层：22(左13,右47)，63（左空，右98）
3层：13(左空,右34) 47(全空) 98（左71，右空）
4层： 34（全空） 71（左空，右90）
5层： 90（右85左空）
6层： 85（全空）
过程是这样的
(1)先插55
(2)22比55小,变55的左子树根结点
(3)63比55大,变55的右子树根结点
(4)47比55小,该变55的左子树根结点,但因为根结点已经存在,所以继续比较,比22大,该插右了,这回没空了吧,落实了,哈哈!
...其它以此类推

你可以发现,每次插入的新结点都是树叶喔,做完后再检查一下,所有结点的左子树结点都比它小,右边的都比它大,就说明你做对了,呵呵! 参考技术A SearchNode(BiTree t,T key,BiTree f,BiTree& p)
if(t == NULL)
p = f;
return false;

else if(key == t->data)
p = t;
return true;

else if(key < t->data)
SearchNode(t->lchild,key,t,p);

else
SearchNode(t->rchild,key,t,p);

参考资料：就是这样

参考技术B 当用线性表作为表的组织形式时，可以有三种查找法。其中以二分查找效率最高。但由于二分查找要求表中结点按关键字有序，且不能用链表作存储结构，因此，当表的插入或删除操作频繁时，为维护表的有序性，势必要移动表中很多结点。这种由移动结点引起的额外时间开销，就会抵消二分查找的优点。也就是说，二分查找只适用于静态查找表。若要对动态查找表进行高效率的查找，可采用下面介绍的几种特殊的二叉树或树作为表的组织形式。不妨将它们统称为树表。下面将分别讨论在这些树表上进行查找和修改操作的方法。

二叉排序树

1、二叉排序树的定义
二叉排序树(Binary Sort Tree)又称二叉查找(搜索)树(Binary Search Tree)。其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：
①若它的左子树非空，则左子树上所有结点的值均小于根结点的值；
②若它的右子树非空，则右子树上所有结点的值均大于根结点的值；
③左、右子树本身又各是一棵二叉排序树。
上述性质简称二叉排序树性质(BST性质)，故二叉排序树实际上是满足BST性质的二叉树。

2、二叉排序树的特点
由BST性质可得：
（1） 二叉排序树中任一结点x，其左(右)子树中任一结点y(若存在)的关键字必小(大)于x的关键字。
（2） 二叉排序树中，各结点关键字是惟一的。
注意：
实际应用中，不能保证被查找的数据集中各元素的关键字互不相同，所以可将二叉排序树定义中BST性质(1)里的"小于"改为"大于等于"，或将BST性质(2)里的"大于"改为"小于等于"，甚至可同时修改这两个性质。
（3） 按中序遍历该树所得到的中序序列是一个递增有序序列。
【例】下图所示的两棵树均是二叉排序树，它们的中序序列均为有序序列：2，3，4，5，7，8。

3、二叉排序树的存储结构
typedef int KeyType； //假定关键字类型为整数
typedef struct node //结点类型
KeyType key； //关键字项
InfoType otherinfo； //其它数据域，InfoType视应用情况而定，下面不处理它
struct node *lchild，*rchild； //左右孩子指针
BSTNode；
typedef BSTNode *BSTree； //BSTree是二叉排序树的类型

堆排序问题

堆排序

堆排序是在二叉树的概念上建立起来的一种排序方式,利用的是二叉树中的完全二叉树;完美二叉树两种树形结构来完成堆排序

关于完全二叉树的概念可以去查阅一些,这里不作详细说明,完美二叉树依据从上至下,从左至右的方式可以转换成一种数组存储结构,每一个节点都是对应数组索引。

基本概念:

　　0.堆排序分为大顶堆,小顶堆,每一个堆都是从大到小和从小到大(堆顶 > 左右 | 堆顶 < 左右)

　　1.按照0索引开始从上至下,N个节点的完全二叉树,最后一个非叶子节点N / 2 - 1,非叶子节点的范围 = [0,N / 2 -1]

　　2.非叶子节(N)点和自己的左(L)右(R)节点的关系:L = N * 2 + 1   R = N * 2 + 2

　　3.堆排序方式:我们从下至上查找,每次完成一个非叶子节点的堆排序,使根节点的值最大,交换根节点和最后一个节点的值

对于从最后一个非叶子节点像上进行推导:

/**
 * 我们从最下最左的非叶子节点开始构建堆,叶子节点本身就是堆了。
 * 我们需要构建最后一个非叶子节点的堆
 * */

public void heap(int[] arr){
    int a = arr.length/2-1; //找到最后一个非叶子节点索引
    int l = a * 2 + 1; //左子节点索引
    int r = a * 2 + 2; //右子节点索引
    int i = 0;
    if(arr[a] < arr[l] || arr[a] < arr[r]){ //我们判定只有当它确实比其中一个小的时候我们才进来判断
        if(arr[l] > r){
            i = arr[a];
            arr[a] = arr[l];
            arr[l] = i;
        }else if(arr[l] < arr[r]){
            i = arr[a];
            arr[a] = arr[r];
            arr[r] = i;
        }
    }
}

/**
 * 倒数第二个非叶子节点
 * */

public void heap_1(int[] arr){
    int a = arr.length/2-2; //找到倒数第二个非叶子节点索引
    int l = a * 2 + 1; //左子节点索引
    int r = a * 2 + 2; //右子节点索引
    int i = 0;
    if(arr[a] < arr[l] || arr[a] < arr[r]){ //我们判定只有当它确实比其中一个小的时候我们才进来判断
        if(arr[l] > r){
            i = arr[a];
            arr[a] = arr[l];
            arr[l] = i;
        }else if(arr[l] < arr[r]){
            i = arr[a];
            arr[a] = arr[r];
            arr[r] = i;
        }
    }
}

问题:当我们改变第二个非叶子节点时,如果该节点和之前的非叶子节点有依赖关系怎么处理?
　　 如果有依赖关系说明非左即右,我们只需要对这个非叶子节点堆发生了交换的节点进行判断是否该节点是非叶子节点,因为完全二叉树的特性,如果是非叶子节点,那么必然是有左节点的。

　　/**
     * 对上一个代码进行完善，heap_2就是一次完整的构建大顶堆的过程
     * 解决问题:如果产生依赖关系如何处理 / 控制所有非叶子节点的遍历 / 该代码可以作为构建堆顶的使用,但是heap_2的优化不足
     * */
    public void heap_2(){
        int i = 0;
        for(int a=arr.length/2-1;a>=0;a--){ //控制非叶子节点的遍历
            int c = a;
            while(c * 2 + 1 < arr.length){  //c就是我们本次进行堆顶节点,如果发生了交换,我们会对交换的节点和堆顶节点进行替换
                int l = c * 2 + 1;
                int r = c * 2 + 2;
            if(arr[c] < arr[l] || arr[c] < arr[r]){
                if(arr[l] > arr[r]){
                    i = arr[c];
                    arr[c] = arr[l];
                    arr[l] = i;
                    c = l;                 //如果是l和c进行了交换
                }else if(l < r){
                    i = arr[c];
                    arr[c] = arr[r];
                    arr[r] = i;
                    c = r;　　　　　　　　//如果是r和c进行了交换
                    }
                 }
            }
        }
    }

/**
 * 优化代码
 * */

public void heap_3(){
    int i = 0;
    for(int a=arr.length/2-1;a>=0;a--){
        int c = a;
        int b  = a;
        while((c = c * 2 + 1) < arr.length){
            if(arr[c] < arr[c+1]){
               c++;
            }
            if(arr[b] < arr[c]){
                i = arr[b];
                arr[b] = arr[c];
                arr[c] = i;
                b = c;
            }
        }
    }
}

当我们从下至上把大/小顶堆构建完成后，需要的就是不停的把堆顶和末尾进行交换,并在中间穿插对依赖的堆重构大/小堆

/**
 * 一下为对堆排序的完整版本
 * */
public void heap_4(int[] arr,int c,int length){
            int i = arr[c];
            for(int b=c*2+1;b<length;b=c*2+1){
                b = b+1<length?arr[b] < arr[b+1]? b+1 : b : b;
                if(arr[b] > i){
                   arr[c] = arr[b];
                   c = b;
                }
            }
            arr[c] = i;
        }
public void heap_5(){
    int temp = 0;
    //大顶堆的整理
    for(int a=arr.length/2-1;a>=0;a--){
        heap_4(arr,a,arr.length);
    }
    //进行交换
    for(int b=arr.length;b>0;b--){
        temp = arr[0];
        arr[0] = arr[b-1];
        arr[b-1] = temp;
　　//从上至下进行整理,因为已经是大顶堆,现在只需要进行对改变的依赖节点进行大顶堆处理
        heap_4(arr,0,b-1);
    }
}