二叉搜索树

数据结构 第四章 浙江大学 mooc 笔记

4.1 二叉搜索树 Binary Search Tree

特点:

• 左边小, 右边大
• 左右子树都是二叉搜索树

二叉搜索树的结构体定义:

typedef int elementType;
typedef struct TreeNode *BinaryTree;
struct TreeNode{
    elementType data;
    BinaryTree Left;
    BinaryTree Right;
};

查找 find(BinTree BST, data) 方式递归:
如果相等 return BST;
if data< BST.data 左边 find
if data>BST.data 右边 find

最小值查找 左子树不空,一直往最左边找
最大值查找 右子树不空,一直往最右边找

深度
找左边高度 LH = 深度()
找右边高度 RH = 深度()
maxH = LH 和 RH 中最大的那个
返回 maxH + 1

插入元素
如果树的节点为空 , 新建 赋值;
如果不空,找到该插入的空的节点位置

删除元素
如果树节点为空, 打印 没找到,或者树为空
如果节点不空,就比较待删除元素值 x 与 当前节点的值的大小BST->data;
xdata 递归删除左边
x>BST->data 递归删除右边
直到找到这个元素或者树节点都不在;
找到它了;
如果它的儿子都存在,把这个x 所在节点的数据 替换为 它右子树最小的值;(或者左子树的最大值)
如果儿子只有一个,把它的儿子赋值给他,再把它通过 tmp释放掉;
最后返回新的树;

/*
 * @Descripttion: 
 * @version: v_1.0.0
 * @Author: Mailor
 * @Email: [email protected]
 * @Date: 2020-12-26 23:53:18
 * @LastEditors: Mailor
 * @LastEditTime: 2020-12-27 15:05:12
 */
#include 
#include 
#include
#include

using namespace std;

typedef bool boolean;
typedef int elementType;
typedef struct TreeNode *BinaryTree;
struct TreeNode{
    elementType data;
    BinaryTree Left;
    BinaryTree Right;
};

BinaryTree initBinaryTree();
BinaryTree insertToBinaryTree(BinaryTree BST,elementType element);

boolean preOrderTraversal(BinaryTree BST);

BinaryTree deleteElement(BinaryTree BST, elementType element);

boolean preOrderTraversal(BinaryTree BST){
    if(!BST){return false;}
    printf("%d\t",BST->data);
    preOrderTraversal(BST->Left);
    preOrderTraversal(BST->Right);
    return true;
}
boolean inOrderTraversal(BinaryTree BST){
    if(!BST){
        return false;
    }
    inOrderTraversal(BST->Left);
    printf("%d\t",BST->data);
    inOrderTraversal(BST->Right);
    return true;
}
BinaryTree find(BinaryTree BST, elementType element){
    if(!BST){
        printf("\nBST 中没有这个元素..");
        return NULL;
        }
    if(element == BST->data){
        return BST;
    }
    if(elementdata){
        return find(BST->Left,element);
    }
    if(element>BST->data){
        return find(BST->Right, element);
    }
    return NULL;
}

BinaryTree findMin(BinaryTree BST){
    if(!BST){
        return NULL;
    }
    if(!BST->Left){return BST;}
    if(BST->Left){
        return findMin(BST->Left);
    }
    return NULL;
}
BinaryTree findMax(BinaryTree BST){
    if(!BST){
        return NULL;
    }
    if(!BST->Right){
        return BST;
    }
    if(BST->Right){
        return findMax(BST->Right);
    }

    return NULL;
}

BinaryTree insertToBinaryTree(BinaryTree BST,elementType element){
    if(!BST){
        BinaryTree BST = (BinaryTree)malloc(sizeof(struct TreeNode));
        BST->data = element ;
        BST->Left = NULL ;
        BST->Right = NULL ;
        return BST;
    }
    if(element>BST->data){
        BST->Right = insertToBinaryTree(BST->Right,element);
    }
    if(elementdata){
        BST->Left = insertToBinaryTree(BST->Left, element);
    }
    if(element == BST->data){
        return BST;
    }
    return BST;
    
}
BinaryTree initBinaryTree(){
    BinaryTree BST = NULL;
    /*
                5
               /\
              3  7
             /\  /\
            1 4 6  8
            \      \
             2      9
    */

    BST = insertToBinaryTree(BST,5); 
    BST = insertToBinaryTree(BST,7); 
    BST = insertToBinaryTree(BST,3); 
    BST = insertToBinaryTree(BST,1); 
    BST = insertToBinaryTree(BST,2); 
    BST = insertToBinaryTree(BST,4); 
    BST = insertToBinaryTree(BST,6); 
    BST = insertToBinaryTree(BST,8); 
    BST = insertToBinaryTree(BST,9); 
    return BST;

}
boolean destroyBST(BinaryTree BST){
    if(!BST){
        return true;
    }
    if(BST){
        destroyBST(BST->Left);
        destroyBST(BST->Right);
        free(BST);
    }
    // BST = NULL;
    return true;
    
}

BinaryTree deleteElement(BinaryTree BST, elementType x){
    BinaryTree tmp;
    if(!BST){
        printf("\n 要删除的元素没有找到;");
    }
    else if(x < BST->data){
        BST->Left = deleteElement(BST->Left,x);
    }
    else if(x > BST->data){
       BST->Right = deleteElement(BST->Right,x);
    }
    else
        if(BST->Left && BST->Right){
            tmp = findMin(BST->Right);
            BST->data = tmp->data;
            BST->Right = deleteElement(BST->Right,BST->data);
        }else{
            tmp = BST;
            if(!BST->Left){
                BST = BST->Right;
            }else if(!BST->Right){
                BST =BST->Left;
            }
            free(tmp);
        }
    return BST;
}
int main(){
    BinaryTree BST = initBinaryTree();
    printf("\n前序遍历结果为: ");
    preOrderTraversal(BST);
    printf("\nBST 中最大元素值为: %d",findMax(BST)->data);

    // printf("\n查找元素3 的中序遍历为:");
    // preOrderTraversal(find(BST,3));

    printf("\n查找元素为 100 是否在 BST 中: ");
    find(BST,100);

    deleteElement(BST,3);
    printf("\n前序遍历结果为: ");
    preOrderTraversal(BST);


    printf("\nBST中最小元素为:%d",findMin(BST)->data);

    printf("\n 中序遍历结果: ");
    inOrderTraversal(BST);
    // printf("\n%d",BST->Left->Right->data);
    return 0;
}