数据结构复习4. 二叉搜索树的插入, 遍历, 节点的删除(C语言实现)

懒得解释了, 直接上代码吧。
有问题私信我。

//
//  Binary_search_tree.c
//  Data_structure
//
//  Created by 양송 on 2020/05/31.
//  Copyright © 2020 양송. All rights reserved.
//

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#define Q_size 50

typedef struct node
{
    int data;
    struct node* left;
    struct node* right;
}Bin_T;

/* 层序遍历时，所用队列*/
Bin_T * Queue[Q_size];
int front = 0;
int rear = 0;

void enQ(Bin_T* T)
{
    if(front == Q_size)
    {
        printf("Q is full\n");
        return;
    }
    else
    {
        Queue[front] = T;
        front++;
    }
}

Bin_T* deQ()
{
    if(rear == front)
    {
        printf("Q is empty\n");
        return NULL;
    }
    else
    {
        Bin_T* node = Queue[rear];
        rear++;
        return node;
    }
}
/************************************************************/

void Create_Tree(Bin_T** T, int num)
{
    if((*T) == NULL)
    {
        Bin_T* new_node = (Bin_T*)malloc(sizeof(Bin_T));
        new_node->data = num;
        new_node->left = NULL;
        new_node->right = NULL;
        *T = new_node;
    }
    else
    {
        if(num > (*T)->data)//如果当前值大于根的值，就插到右边
        {
            Create_Tree(&(*T)->right, num);
        }
        else
        {
            Create_Tree(&(*T)->left, num);
        }
    }
}

void insert_node(Bin_T** T, int num)
{
    Create_Tree(T, num);
}
void Binary_tree_search(Bin_T* T, Bin_T** search,int num)
{
    if(T == NULL)
    {
        return;
    }
    else
    {
        if(num > T->data)
        {
            Binary_tree_search(T->right,search, num);
        }
        else if(num < T->data)
        {
            Binary_tree_search(T->left,search, num);
        }
        else
        {
            *search = (Bin_T*)malloc(sizeof(Bin_T));//如果没有找到 search 会为NULL
            *search = T;
            return;
        }
    }
}

//二叉树搜索
int search(Bin_T* T, Bin_T* search, int num)
{
    Binary_tree_search(T, &search, num);
    if(search == NULL)
    {
        printf("not found\n");
        return 0;
    }
    else
    {
        return 1;
    }
}

//辅助节点删除
void Get_Father_node(Bin_T* T, Bin_T* child_node, Bin_T** father_node)
{
    if(T!=NULL)
    {
        
        if(T->left == child_node || T->right == child_node)
        {
            *father_node = T;
            return;
        }
        else
        {
            Get_Father_node(T->left, child_node,father_node);
            Get_Father_node(T->right, child_node,father_node);
        }
    }
}
//节点的删除,是真的麻烦
void Binary_tree_delete_node(Bin_T* T, Bin_T* temp, int num)
{
    if(T == NULL)
    {
        printf("tree is empty\n");
        return;
    }
    else
    {
        else if(num > T->data)
        {
            Binary_tree_delete_node(T->right,temp, num);
        }
        else if(num < T->data)
        {
            Binary_tree_delete_node(T->left,temp, num);
        }
        else //找到该值
        {
            if(T->left == NULL && T->right == NULL)//如果是叶节点
            {
                Bin_T* father_node = NULL;
                Get_Father_node(temp, T,&father_node);//第一个参数永远在根的位置，T为找到的节点位置
                if(father_node->left == T)
                {
                    father_node->left = NULL;
                    free(temp);
                }
                else if(father_node->right == T)
                {
                    father_node->right = NULL;
                    free(temp);
                }
                
            }
            else if(T->left == NULL || T->right == NULL) //如果有一个子节点
            {
                if(T->left == NULL&& T->right!=NULL)//左边是空的，那我们使用右边
                {
                    Bin_T* father_node = NULL;
                    Get_Father_node(temp, T, &father_node);
                    father_node->right = T->right;
                    free(T);
                }
                else if(T->left != NULL && T->right == NULL)//右边是空的，使用左边的子节点
                {
                    Bin_T* father_node = NULL;
                    Get_Father_node(temp, T, &father_node);
                    father_node->left = T->left;
                    free(T);
                }
            }
            else// 使用左子树最右边的节点
            {
                Bin_T* ptr = T->left;
                while(ptr->right!=NULL)
                {
                  ptr = ptr->right;
                }
                T->data = ptr->data;
                //找到ptr的父节点
                Bin_T* father_node = NULL;
                Get_Father_node(temp, ptr, &father_node);
                if(father_node->right == ptr && ptr->left != NULL)
                {
                   father_node->right = ptr->left;
                    
                   free(ptr);
                }
                else
                {
                    father_node->right = NULL;
                    free(ptr);
                }
            }
        }
    }
}


//使用队列
void Level_Order(Bin_T* T)
{
    if(T == NULL)
    {
        printf("Tree empty\n");
        return;
    }
    else
    {
        enQ(T); //将root入队列
        
        while(front != rear)
        {
            Bin_T* temp = deQ();
            
            if(temp->left!=NULL)
            {
                enQ(temp->left);
            }
            
            if(temp->right != NULL)
            {
                enQ(temp->right);
            }
            
            printf("%d ",temp->data);
        }
    }
}

/* 遍历(递归)*/
void Pre_Order(Bin_T* T)
{
    if(T == NULL)
    {
        return;
    }
    else
    {
        printf("%d ", T->data);
        Pre_Order(T->left);
        Pre_Order(T->right);
    }
}

void In_Order(Bin_T* T)
{
    if(T == NULL)
    {
        return;
    }
    else
    {
        In_Order(T->left);
        printf("%d ", T->data);
        In_Order(T->right);
    }
}

void Post_Order(Bin_T* T)
{
    if(T == NULL)
    {
        return;
    }
    else
    {
        Post_Order(T->left);
        Post_Order(T->right);
        printf("%d ",T->data);
    }
}

int main()
{
    int ele[] = {61, 87, 59, 47, 35, 73, 51, 98, 37, 93,36};
    Bin_T* T = NULL;
    for(int i = 0; i< 11;i++)
    {
        Create_Tree(&T, ele[i]);
    }
    
    printf("层序遍历:");
    Level_Order(T);
    printf("\n");
    
    printf("前序遍历:");
    Pre_Order(T);
    printf("\n");
    
    printf("中序遍历:");
    In_Order(T);
    printf("\n");
    
    printf("后序遍历:");
    Post_Order(T);
    printf("\n");
    
    printf("删除元素47\n");
    Binary_tree_delete_node(T, T,47);
    printf("层序遍历:");
    Level_Order(T);
    printf("\n");

    
}