最全数据结构个人笔记【树-BST】

最新推荐文章于 2024-09-25 21:57:34 发布
最新推荐文章于 2024-09-25 21:57:34 发布
阅读量506 收藏 7
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 笔记 链表 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58204972/article/details/140806146
版权

1.BST的基本概念

​ 二叉树的其中一个重要应用，就是提供一种快速查找数据的方法，即将数据节点按照某种规律形成一棵二叉树，然后利用二叉树特殊的逻辑结构减少搜索数据的次数，提高查找效率。这种按照某中规律构建，用来提高搜索性能的二叉树，被称为搜索二叉树(Binary Search Tree)，即BST。

具体而言，二叉树提高搜索效率的秘诀在于：按照"小-中-大"(当然"大-中-小"也是一样)的规律来存储数据，即对于任意一个节点，都可以明确找到其值大于或等于其左孩子节点，且小于或等于其有孩子节点，如图所示:

​ 在这里插入图片描述

由于树中所有的节点均满足，“小-中-大”的规律因此当从根开始查找某个节点时速度比顺序查找要快的多，比如要找节点38,当发现38大于根节点13后，就可以确定13的左子树一定没有38，这就去掉了半边子树的节点

因此二叉搜索树又称为二叉排序树、二叉查找树。

实际上，对于一棵二叉树而言，其搜索节点的时间复杂度，最糟糕的情形是其退化成链表，最乐观的情形是完全二叉树，那么其搜索时间复杂度就是介于: 最差 ： T(n)=O(n) 最优 ： T(n)=O(log2n)

2.插入节点

​ 对于BST而言，插入一个节点主要是要保持其"小-中-大"的逻辑不变，因此插入的的逻辑可以从根节点开始，一步一步寻找新节点的"最终归宿"，比如在如下BST中，要插入新节点16，最终应该插入到节点17的左孩子处。

在这里插入图片描述

在实现插入算法的时候，由于树状结构本身是递归的，因此可以使用递归函数更优雅地实现插入算法。如下：

// 假设 BST 节点存储的数据类型是 int
node *newNode(int data)
{
    // 准备好新节点，并将数据填入其中
    node *new = (node *)malloc(sizeof(node));
    if(new != NULL)
    {
        new->data = data;
        new->lchild = NULL;
        new->rchild = NULL;
    }
    return new;
}

// 将新节点new插入到一棵以 root 为根的 BST 中
// 插入节点后，返回新的 BST 的根
node *bstInsert(node *root, node *new)
{
    // 若此时 BST 为空，则返回 new 使之成为二叉树的根节点
    if(root == NULL)
        return new;

    // 若新节点比根节点小，那么新节点应该插入左子树中
    // 至于插入到左子树的具体什么位置就不用管了，直接递归即可
    if(new->data < root->data)
        root->lchild = bstInsert(root->lchild, new);

    // 若新节点比根节点大，那么新节点应该插入右子树中
    // 至于插入到右子树的具体什么位置就不用管了，直接递归即可
    else if(new->data > root->data)
        root->rchild = bstInsert(root->rchild, new);

    // 若已存在，则不处理
    else
    {
        printf("%d已存在\n", new->data);
        free(new);
    }

    return root;
}

​ 「课堂练习3」

根据上述BST的插入算法，依次输入如下数据：8、3、1、6、4、7、10、14、13
创建如下二叉树：

在这里插入图片描述

提示：
为了检验创建出来的二叉树是否正确，可以使用如下代码将二叉树以网页形式展现出来：

  • drawtree.h
///
//
//  Copyright(C), 2013-2017, GEC Tech. Co., Ltd.
//
//  文件: lab/tree/headers/drawtree.h
//  日期: 2017-9
//  描述: 使用C语言写一页webpage展示二叉树
//
///

#ifndef _DRAWTREE_H_
#define _DRAWTREE_H_

/* ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 公共头文件 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
//#include <unistd.h>
#include <string.h>
//#include <strings.h>
#include <time.h>
#include <errno.h>
#include<unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>

// #include <sys/ipc.h>
// #include <sys/sem.h>
// #include <sys/shm.h>
// #include <sys/msg.h>
// #include <semaphore.h>
#include <fcntl.h>

//#include <pthread.h>
/* ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 公共头文件 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ */

#define MAX(a, b) ({ \
		typeof(a) _a = a; \
		typeof(b) _b = b; \
		(void)(&_a == &_b);\
		_a > _b? _a : _b; \
		})


/* ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ 默认二叉树节点 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
typedef struct _tree_node
{
	int data;
	struct _tree_node *lchild;
	struct _tree_node *rchild;

#ifdef AVL
	int height;
#endif

#ifdef RB
	struct _tree_node *parent;
	int color;
#endif
}_treenode, *_linktree;
/* ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ 默认二叉树节点 ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ */


/* ↓↓↓↓↓ 用户指定二叉树节点 ↓↓↓↓↓ */
#ifndef NODE
#define NODE _treenode
#endif
/* ↑↑↑↑↑ 用户指定二叉树节点 ↑↑↑↑↑ */



/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */

#ifndef QUEUE_NODE_DATATYPE
#define QUEUE_NODE_DATATYPE NODE *
#endif

typedef QUEUE_NODE_DATATYPE qn_datatype;

struct _queue_node
{
	qn_datatype data;
	struct _queue_node *next;

};

typedef struct
{
	struct _queue_node *front;
	struct _queue_node *rear;
#ifdef QUEUE_SIZE
	int size;
#endif
}_queuenode, *_linkqueue;


static _linkqueue init_queue(void)
{
    _linkqueue q = (_linkqueue)malloc(sizeof(_queuenode));
	q->front = q->rear =
		(struct _queue_node *)malloc(sizeof(struct _queue_node));
	q->rear->next = NULL;

	return q;
}

static bool is_empty_q(_linkqueue q)
{
	return (q->front == q->rear);
}

/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
static bool out_queue(_linkqueue q, qn_datatype *pdata)
{
	if(is_empty_q(q))
		return false;

	struct _queue_node *p = q->front;

	q->front = q->front->next;
	free(p);
	*pdata = q->front->data;

	return true;
}

static bool en_queue(_linkqueue q, qn_datatype data)
{
	struct _queue_node *pnew;
	pnew = (struct _queue_node *)malloc(sizeof(struct _queue_node));
	if(pnew == NULL)
		return false;

	pnew->data = data;
	pnew->next = NULL;

	q->rear->next = pnew;
	q->rear = pnew;

	return true;
}

#ifdef QUEUE_SIZE
int queue_size(_linkqueue *q)
{
	return q->size;
}
#endif
/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */


static void pre_travel(NODE *root, void (*handler)(NODE *))
{
	if(root == NULL)
		return;
	
	handler(root);
	pre_travel(root->lchild, handler);
	pre_travel(root->rchild, handler);
}

static void mid_travel(NODE *root, void (*handler)(NODE *))
{
	if(root == NULL)
		return;
	
	mid_travel(root->lchild, handler);
	handler(root);
	mid_travel(root->rchild, handler);
}

static void post_travel(NODE *root, void (*handler)(NODE *))
{
	if(root == NULL)
		return;

	post_travel(root->lchild, handler);
	post_travel(root->rchild, handler);
	handler(root);
}

/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
static void level_travel(NODE *root, void (*handler)(NODE *))
{
	if(root == NULL)
		return;

    _linkqueue q;
	q = init_queue();

	en_queue(q, root);

    NODE *tmp;
	while(1)
	{
		if(!out_queue(q, &tmp))
			break;

		handler(tmp);

		if(tmp->lchild != NULL)
			en_queue(q, tmp->lchild);
		if(tmp->rchild != NULL)
			en_queue(q, tmp->rchild);
	}
}
/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
static char page_begin[] = "<html><head><title>tree map"
                           "</title></head><body>"
			   "<table border=0 cellspacing"
                           "=0 cellpadding=0>";
static char line_begin[] = "<tr>";
static char line_end  [] = "</tr>";
static char space     [] = "<td>&nbsp;</td>";
static char underline [] = "<td style=\"border-bottom:"
	 		   "1px solid #58CB64\">&nbsp;"
                           "</td>";

#ifdef RB
static char data_begin_red[] = "<td bgcolor=\"#FF0000\";style="
			       "\"border:1px sol"
                               "id #58CB64;background-colo"
                               "r:#DDF1D8;PADDING:2px;\" t"
                               "itle=\"level: 1\">";
static char data_begin_blk[] = "<td bgcolor=\"#000000\";style="
			       "\"border:1px sol"
                               "id #58CB64;background-colo"
                               "r:#DDF1D8;PADDING:2px;\" t"
                               "itle=\"level: 1\"><font color"
				"=\"#FFFFFF\">";
static char data_end_red[] = "</td>";
static char data_end_blk[] = "</font></td>";
#else
static char data_begin[] = "<td style=\"border:1px sol"
                           "id #58CB64;background-colo"
                           "r:#DDF1D8;PADDING:2px;\" t"
                           "itle=\"level: 1\">";
static char data_end  [] = "</td>";
#endif

static char page_end  [] = "</table></body></html>";

#define MAX_NODES_NUMBER 100
#define FILENAME 32

static int central_order[MAX_NODES_NUMBER];

static void putunderline(int fd, int num)
{
	int i;
	for(i=0; i<num; i++)
	{
		write(fd, underline, strlen(underline));
	}
}


static void putspace(int fd, int num)
{
	int i;
	for(i=0; i<num; i++)
	{
		write(fd, space, strlen(space));
	}
}
/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
#ifdef RB
static void putdata(int fd, NODE * p)
{
	char s[50];
	bzero(s, 50);

	snprintf(s, 50, "%d", p->data);

	switch(p->color)
	{
	case RED:
		write(fd, data_begin_red, strlen(data_begin_red));
		write(fd, s, strlen(s));
		write(fd, data_end_red, strlen(data_end_red));
		break;
	case BLACK:
		write(fd, data_begin_blk, strlen(data_begin_blk));
		write(fd, s, strlen(s));
		write(fd, data_end_blk, strlen(data_end_blk));
	}
}
#else
static void putdata(int fd, int data)
{
	char s[50] = {0};
	//bzero(s, 50);

	snprintf(s, 50, "%d", data);
	write(fd, data_begin, strlen(data_begin));
	write(fd, s, strlen(s));
	write(fd, data_end, strlen(data_end));
}
#endif

static int Index = 0;
static void create_index(NODE * root)
{
	if(Index >= MAX_NODES_NUMBER-1)
		return;

	central_order[Index++] = root->data;
}


static int get_index(int data)
{
	int i;
	for(i=0; i<100; i++)
	{
		if(central_order[i] == data)
			return i;
	}
	return -1;
}

/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
static void data_leftside(int fd, NODE * root, int spaces)
{
	if(root == NULL)
		return;

	int s_line=0;

	if(root->lchild != NULL)
	{
		s_line = get_index(root->data)-
			 get_index(root->lchild->data)-1;
	}
	putspace(fd, spaces-s_line);
	putunderline(fd, s_line);
}


static int data_rightside(int fd, NODE * root)
{
	if(root == NULL)
		return 0;

	int s_line=0;

	if(root->rchild != NULL)
	{
		s_line = get_index(root->rchild->data)-
			 get_index(root->data)-1;
	}

	putunderline(fd, s_line);
	return s_line;
}


static void start_page(int fd)
{
	write(fd, page_begin, strlen(page_begin));
}

/* ↓↓↓↓↓↓↓↓↓↓↓↓↓ 画网页相关算法代码 ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ */
static void end_page(int fd)
{
	write(fd, page_end, strlen(page_end));
}

// 显示
static void draw(NODE * root)
{
	if(root == NULL)
		return;

	time_t t;
	time(&t);
	static char filename[FILENAME] = {0};
	//bzero(filename, FILENAME);
	snprintf(filename, FILENAME, "%u.html", (unsigned)t);
	int fd = open(filename, O_CREAT | O_TRUNC | O_RDWR, 0644);
	if(fd == -1)
	{
		perror("open() failed");
		exit(1);
	}

	Index = 0;
	mid_travel(root, create_index);

    _linkqueue q = init_queue();

	NODE * tmp = root;
	int ndata = 1;

	start_page(fd);
	while(1)
	{
		write(fd, line_begin, strlen(line_begin));

		int i, n = 0;
		int nextline = 0;
		for(i=0; i<ndata; i++)
		{
			int index = get_index(tmp->data);

			data_leftside(fd, tmp, index-n);

			#ifdef RB
			putdata(fd, tmp);
			#else
			// 如果想要在网页上显示字符，将putdata函数里面的sprintf()的%d换成%c
			putdata(fd, tmp->data);
			#endif
			int rightline = data_rightside(fd, tmp);

			if(tmp->lchild != NULL)
			{
				nextline++;
				en_queue(q, tmp->lchild);
			}
			if(tmp->rchild != NULL)
			{
				nextline++;
				en_queue(q, tmp->rchild);
			}
			if(!out_queue(q, &tmp))
				return;

			n = index + rightline;
			n++;
		}
		write(fd, line_end, strlen(line_end));
		ndata = nextline;
	}
	end_page(fd);
	close(fd);
}
#endif


#define TREENODE node // 声明自定义的二叉树节点为TREENODE
#include "drawtree.h" // 包含画树代码

int main()
{
    ...

    // 以网页形式展现二叉树
    draw(root);
}

其中，node是自己定义的二叉树的节点的类型，在包含 drawtree.h 之前定义 TREENODE 这个宏为 node ，即可展示对应二叉树。

在这里插入图片描述

遍历代码

以上述练习中的二叉树为例，采用前、中、后序遍历的算法示例代码如下：

// 前序遍历
void preOrder(node *root)
{
    if(root == NULL)
        return;

    // 先访问根节点
    printf("%d", root->data);

    // 再依次使用前序算法，遍历其左、右子树
    preOrder(root->lchild);
    preOrder(root->rchild);
}

「课堂练习4」

将下面这棵二叉树，按照前序、中序、后序方式，编程实现输出其各个节点的值。

在这里插入图片描述

// 先序遍历
void pre_order(BSTNode *root)
{
    if(root == NULL)// 叶子节点
        return;
    printf("%d\t",root->data);
    // 遍历左子树，作为root节点
    pre_order(root->lchild);
    // 遍历右子树，作为root节点
    pre_order(root->rchild);
}

// 中序遍历
void mid_order(BSTNode *root)
{
    if(root == NULL)
        return;

    // 先遍历左子树
    mid_order(root->lchild);
    // 输出根节点
    printf("%d\t",root->data);
    // 遍历右子树
    mid_order(root->rchild);
}

// 后序遍历
void post_order(BSTNode *root)
{
    if(root == NULL)
        return;

    // 先遍历左子树
    post_order(root->lchild);
    // 遍历右子树
    post_order(root->rchild);
    // 输出根节点
    printf("%d\t",root->data);
}

删除节点

删除一个BST的节点要比插入困难一点，但同样是要遵循一个原则，即：删除节点后仍然要保持“小-中-大”的逻辑关系。

非递归思路

在这里插入图片描述

// 创建新节点
BSTNode *CreateNode(dataType data)
{
    BSTNode *pnew = malloc(sizeof(BSTNode));
    if (pnew == NULL)
        return NULL;

    pnew->data = data;
    pnew->lchild = NULL;
    pnew->rchild = NULL;

    return pnew;
}


//非递归——删除
BSTNode *DeleteNode(BSTNode *root,dataType d)
{
    //查找
    BSTNode *p = root;//遍历指针
    BSTNode *pF = NULL;     //指向p节点的父节点pF

    while (p)
    {
        if( d == p->data )  // 找到需要剔除的节点
            break;
        else if (d < p->data)     // 从左子树继续找
        {
            pF = p;
            p = p->lchild;
        }
        else 
        {
            pF = p ;
            p = p->rchild;
        }
        
    }
    
    // 找不到
    if(p == NULL)
        return root;

    //删除
Delete:
    //1—— p没有孩子
    if(p->lchild == NULL && p->rchild == NULL)    //p无孩子
    {
        //无父节点
        if(pF == NULL)  //删除的就是根节点，且这棵树只有一个节点
        {
            free(p);
            root = p = NULL;
            return NULL;
        }
        //有父结点  
        else if(pF ->lchild == p)   //p是pF左孩子
        {
            pF->lchild = NULL;
            free(p);
            p = NULL;
        }
        else                   //p是pF右孩子
        {
            pF->rchild = NULL;
            free(p);
            p = NULL;
        }
    }
    //2—— p有1个孩子
    else if(p->lchild != NULL && p->rchild == NULL)   //有左子节点
    {
         //有无父节点
        if(pF == NULL)  //删除的就是根节点
        {
            root = p->lchild;
            p->lchild = NULL;
            free(p);
            p = NULL;
        }
 
        else if(pF ->lchild == p)   //p是pF左孩子
        {
           pF->lchild = p->lchild;
           p ->lchild = NULL;
           free(p);
           p = NULL;
        }
        else if(pF ->rchild == p)   //p是pF右孩子
        {
            pF->rchild = p->lchild;
            p ->lchild = NULL;
            free(p);
            p = NULL;
        }
    }
    else if(p->lchild == NULL && p->rchild != NULL)   //有右子节点
    {
        //有无父节点
        if(pF == NULL)  //删除的就是根节点
        {
            root = p->rchild;
            p->rchild = NULL;
            free(p);
            p = NULL;
        }
 
        else if(pF ->lchild == p)   //p是pF左孩子
        {
           pF->lchild = p->rchild;
           p ->rchild = NULL;
           free(p);
           p = NULL;
        }
        else if(pF ->rchild == p)   //p是pF右孩子
        {
            pF->rchild = p->rchild;
            p ->rchild = NULL;
            free(p);
            p = NULL;
        }
    }

    //3—— p有2个孩子
    else    
    {   //左子树中找最大 或者 右子树中找最小
        BSTNode *pK = p->lchild;    //pK去左子树中找最大

        // 找p的左子树最大值pK
        // 如果pK的右孩子为空，表示pK为p左子树的最大节点
        while (pK->rchild)
        {
            pF = pK;
            pK = pK->rchild;
        }
        //此时pK所在位置就是替换位置
        
        //pK为p的左孩子
        if(pK  == p->lchild)
        {
            // p和pK交换删除pK
            p->data = pK->data;
            p->lchild = pK->lchild;
            pK->lchild = NULL;
            free(pK);
        }
        else
        {
            // p和pK交换删除pK
            p->data = pK->data;
            pF->rchild = pK->lchild;
            pK->lchild = NULL;
            free(pK); 
        }

    }
    return root;
}


// 将一个节点插入到BST树
BSTNode *InsertNode(BSTNode *root, dataType data)
{
    // 创建节点
    BSTNode *pnew = CreateNode(data);
    if (pnew == NULL)
    {
        printf("Memory allocation failed\n");
        return root;
    }

    // 遍历指针p
    BSTNode *p = root;
    // 从无到有
    if (root == NULL)
    {
        root = pnew;
    }
    else // 从少到多
    {
        while (1)
        {
            if (p->data > data) // 插入左子树
            {
                if (p->lchild == NULL) // 有位置插入
                {
                    p->lchild = pnew;
                    break;
                }
                else // 接着往下找
                    p = p->lchild;
            }
            else if (p->data < data) // 插入右子树
            {
                if (p->rchild == NULL)
                {
                    p->rchild = pnew;
                    break;
                }
                else
                    p = p->rchild;
            }
            else
            {
                printf("insert data failed:\n");
                free(pnew);
                break;
            }
        }
    }

    return root;

}

// 创建BST树
BSTNode *CreateBST(void)
{
    BSTNode *root = NULL;
    dataType data;
    while (1)
    {
        if (scanf("%d", &data) == 0)
        {
            while (getchar() != '\n');
            break;
        }

        root = InsertNode(root, data);
    }

    return root;
}

//前序遍历
void PreOrder(BSTNode *root)
{
    if(root == NULL)
        return ;
    
    //先访问根节点
    printf("  %d  ",root->data);
    PreOrder(root->lchild);
    PreOrder(root->rchild);
}

//中序遍历
void MidOrder(BSTNode *root)
{
    if(root == NULL)
        return ;
    

    MidOrder(root->lchild);
    printf("  %d  ",root->data);
    MidOrder(root->rchild);

}

//后序遍历
void PostOrder(BSTNode *root)
{
    if(root == NULL)
        return ;

    PostOrder(root->lchild);
    PostOrder(root->rchild);
    printf("  %d  ",root->data);
}

/*
    LevelTravel:    对一棵二叉排序树进行层次遍历
*/
void LevelTravel(BSTNode *root)
{
    printf("LevelTravel:");
    if (root == NULL)
        return;
    //创建队列
    LinkedQueue *q = InitQueue();                   // 初始
    if(q==NULL)
        return;

    //根节点入队
    EnQueue(q,root);

    while (!IsEmpty(q))
    {
        //出队
        QElemType d;
        DeQueue(q,&d);
        printf("  %d  ",d->data);

        //出队元素的孩子节点入队
        if(d->lchild)
            EnQueue(q,d->lchild);
        if(d->rchild)
            EnQueue(q,d->rchild);
    }
    
    //销毁队列
    DestroyQueue(q);
    printf("\n");
}

/*
    LevelTravel:    求一棵二叉排序树深度
*/
int GetDepth(BSTNode*root)
{
    if(root == NULL)
        return 0;
    int L = GetDepth(root->lchild);
    int R = GetDepth(root->rchild);
    return L > R ? L+1 : R+1;
}
递归思路

假设要删除的节点是x，大体思路如下：

  1. 若要删除的节点小于根节点，则递归地在左子树中删除x

  2. 若要删除的节点大于根节点，则递归地在右子树中删除x

  3. 若要删除的节点恰好就是根节点，则分如下几种情况：
    a. 根节点若有左子树，则用左子树中最大的节点max替换根节点，并在左子树中递归删除max
    b. 否则，若有右子树，则用右子树中最小的节点min替换根节点，并在右子树中递归删除min
    c. 否则，直接删除根节点

以下图为例，假设在一棵二叉树中要删除节点15，在找到节点之后，判断其有左子树，那么就沿着其左子树找到最右下角（最大）的节点19，替换要删除的节点15，然后再将多余的节点19删掉：

在这里插入图片描述

删除一个有左子树的节点过程

而如果要删除的节点没有左子树，只有右子树，那么情况是完全对称的，如下图所示，假设要删除节点25，由于25没有左子树，因此找到其右子树中最左下角（最小）的节点16，替换要删除的节点25，然后再将多余的节点16删掉：

在这里插入图片描述

删除一个只有右子树的节点过程

代码如下：

// 将数据（以整型为例）data从二叉树中删除
// 并返回删除之后的二叉树的根
node *bstRemove(node *root, int data)
{
    if(root == NULL)
        return NULL;

    // 若data小于根节点，则递归地在左子树中删除它
    if(data < root->data)
        root->lchild = bstRemove(root->lchild, data);

    // 若data小于根节点，则递归地在左子树中删除它
    else if(n > root->data)
        root->rchild = bstRemove(root->rchild, data);

    // 若data恰好就是根节点，则分如下几种情况：  
    else
    {
        // a. 根节点若有左子树，则用左子树中最大的节点max替换根节点
        //    并在左子树中递归删除max  
        if(root->lchild != NULL)
        {
            node *max;
            for(max=root->lchild; max->rchild!=NULL;
                max=max->rchild);

            root->data = max->data;
            root->lchild = bstRemove(root->lchild, max->data);
        }

        // b. 否则，若有右子树，则用右子树中最小的节点min替换根节点
        //    并在右子树中递归删除min  
        else if(root->rchild != NULL)
        {
            for(tmp=root->rchild; tmp->lchild!=NULL;
                tmp=tmp->lchild);

            root->data = tmp->data;
            root->rchild = bst_remove(root->rchild, tmp->data);
        }

        // c. 否则，直接删除根节点
        else
        {
            free(root);
            return NULL;
        }
    }

    return root;
}

data = max->data;
root->lchild = bstRemove(root->lchild, max->data);
}

    // b. 否则，若有右子树，则用右子树中最小的节点min替换根节点
    //    并在右子树中递归删除min  
    else if(root->rchild != NULL)
    {
        for(tmp=root->rchild; tmp->lchild!=NULL;
            tmp=tmp->lchild);

        root->data = tmp->data;
        root->rchild = bst_remove(root->rchild, tmp->data);
    }

    // c. 否则，直接删除根节点
    else
    {
        free(root);
        return NULL;
    }
}

return root;

}
DS陈工
关注
专栏目录
数据结构 ： 二叉搜索树(BST)
LOOKTOMMER的博客
10-07 1343
????‍???? ????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍????????‍??????
数据结构与算法学习笔记十二--多叉树
weixin_44501366的博客
04-28 351
1. 二叉树的问题分析 二叉树的操作效率较高，但是也存在问题： 二叉树需要加载到内存的，如果二叉树的节点少，没有说明问题，但是如果二叉树的节点很多（比如1亿），就存在如下问题： 问题1：在构建二叉树时，需要多次进行 i/o操作（海量数据存在数据库或者文件中），节点海量，构建二叉树时，速度有影响。 问题2：节点海量，也会造成二叉树的高度很大，会降低操作速度。 2. 多叉树与B树 多叉树 在二叉树中，每个节点有数据项，最多有两个子节点。如果允许每个节点可以有更多的数据项和更多的子节点，就是多叉树（mult
【二叉树】数据结构——BST二叉树基本概念及算法设计（插入、删除、遍历操作）
皮皮不调皮的博客
03-29 4856
二叉树一、二叉树基本概念二、二叉树的算法设计1、构建二叉树节点2、插入节点3、删除节点4、遍历二叉树5、层次遍历 一、二叉树基本概念 二叉树的其中一个重要应用，是提供一种快速查找数据的方法，即：将数据节点按照某种规律形成一棵二叉树，然后利用二叉树特殊的逻辑结构减少搜索数据的次数，提高查找的效率。 这种按照某种规律构建，用来提高搜索性能的二叉树，被称为搜索二叉树（Binary Search Tree），即BST。 具体而言，二叉树提高搜索效率的秘诀在于：按照“小-中-大”（当然“大-中-小”也是一样的）的规律
BST-二叉搜索树
最新发布
何春秋的博客
09-25 1071
二叉搜索树 Java实现
【数据结构】-二叉搜索树(BST)
knoci的博客
04-23 1308
如图所示，二叉搜索树（binary search tree）满足以下条件。对于根节点，左子树中所有节点的值 < 根节点的值 < 右子树中所有节点的值。任意节点的左、右子树也是二叉搜索树，即同样满足条件1.。二分搜索树有着高效的插入、删除、查询操作。平均时间的时间复杂度为 O(log n)，最差情况为 O(n)。二分搜索树与堆不同，不一定是完全二叉树，底层不容易直接用数组表示故采用链表来实现二分搜索树。只有在高频添加、低频查找删除数据的场景下，数组比二叉搜索树的效率更高。查找元素插入元素。
二叉树算法的设计
weixin_30785593的博客
07-18 426
二叉树算法的设计的总路线：明确一个节点要做的事情，然后剩下的事抛给框架。 void traverse(TreeNode root) { // root 需要做什么？在这做。 // 其他的不用 root 操心，抛给框架 traverse(root.left); traverse(root.right); } 举两个简单的例子体会一下这个思路，热热...
二叉树算法设计
jing7012796的专栏
11-14 703
6. 二叉树算法设计（3人） 【可操作的菜单项目】  (1)  创建二叉树； （2） 显示二叉树 （3） 求树高 （4） 统计叶子结点 【基本要求】 (1）建立含有若干个元素的二叉链表，要求从文件读入数据，显示函数公用。     (2）计算并显示二叉树的高度。     (3）计算并显示二叉树叶子结点数。
Java数据结构与算法-笔记-代码-课件-资料
05-17
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与...斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)等...
算法数据结构学习笔记-C语言.zip
01-01
1. 数组：数组是最基本的数据结构，它是一系列相同类型的元素集合，通过索引访问。C语言中可以直接声明数组，例如`int arr[10]`表示一个包含10个整数的数组。数组的索引从0开始，可以通过`arr[i]`来访问第i个元素。 ...
笔记11-数据结构之MAP和SET
12-14
数据结构是计算机科学中最重要的基础知识之一，Map 和 Set 是两种常用的数据结构，下面我们来详细介绍它们。 一、Map Map 也称为映射或哈希表，是一种数据结构，它存储着键值对（key-value）的集合。Map 中每个...
数据结构高分笔记
08-08
### 数据结构高分笔记知识点详解 #### 一、引言 数据结构作为计算机科学的核心课程之一，在计算机专业研究生入学考试中占据着极其重要的位置。然而，由于数据结构本身概念繁多、逻辑性强等特点，很多考生在备考...
二叉树相关算法设计题
weixin_34273046的博客
04-03 313
一. 题目： 二叉树按层打印，同时输出格式满足：打印完一层要换行，每一行的行首标明：level i(i=1,2,3...层) 如：　　　　1 　　　　2 3 　　4 5 输出打印为： level1: 1 level2: 2 3 level3:4 5 思路：1.先把二叉树的层次遍历搞懂： 　　　 　　用队列实现，原理是...
数据结构与算法——BST树
weixin_54670782的博客
03-20 1004
BST树的定义：二叉排序树，二叉搜索树。 二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树： 每个结点都有一个作为搜索依据的关键码（key),所有结点的关键码互不相同。 左子树（如果存在）上所有结点的关键码都小于根结点的关键码。 右子树（如果存在）上所有结点的关键码都大于根结点的关键码。 左子树 和右子树也是二叉搜索树。 总结：如果一棵二叉搜索树进行中序遍历，可以按从小到大的顺序，将各个节点关键码排列起来，所以也称二叉搜索树为二叉排序树。 结构设计： typedef int KeyType;
算法 二叉树 BST树
XXXTENTAC1ON的博客
05-07 2255
二叉排序树BST树的定义BST树结构BST树的创建递归中序遍历非递归中序遍历逆向非递归中序遍历删除结点 BST树的定义 BST树又称为：二叉排序树，二叉搜索树 二叉搜索树或者是一颗空树，或者是具有下列性质的二叉树 每个结点都有一个作为搜索依据的关键码(key)，所有结点的关键码互不相同 左子树（如果存在）上所有结点的关键码都小于根节点的关键码 右子树（如果存在）上所有结点的关键码都大于根节点的关键码 左子树和右子树也是二叉搜索树 总结：如果对一颗二叉搜索树进行中序遍历，可以按从小到大的顺序，将各结
二叉排序树的查找、插入和删除
迷之月光的专栏
03-04 2493
1.      二叉排序树 二叉排序树(Binary Sort Tree)或者是一棵空树，或者是具有下列性质的二叉树： (1)若左子树不空，则左子树上所有结点的值均小于它的根结点的值； (2)若右子树不空，则右子树上所有结点的值均大于它的根结点的值； (3)左、右子树也分别为二叉排序树； (4)没有结点值相同的结点。 二叉排序树又称二叉查找树(Binary Search Tree)
【数据结构】二叉树一些基本算法
WZ_GOGO的博客
10-10 198
二叉树中搜索某个元素的算法。 /** * 查找二叉树中元素 * @param root * @param data * @return */ Boolean FinadInBT(BT root, int data) { Boolean temp; if (root == null) return false; else { if (data =...
数据结构-二叉查找树(BST)
yueh0607
10-09 333
每次都能根据大小去舍弃另一半的分支，极大的减少的比对次数。二叉树的前驱和后继是按中序遍历计算的，L称为前驱，R为后继。BST的删除比较复杂，需要先了解二叉树的遍历顺序。具体的性能，取决于树的层数和平衡程度。
【数据结构】二叉查找树（BST）
m0_46628950的博客
09-08 7610
二叉查找树(Binary Search Tree，BST)，又叫做二叉排序树、二叉搜索树，是一种对查找和排序都有用的特殊二叉树。二叉查找树的特性：左子树
大学生数据结构学习笔记与资料大全
2. 树形数据结构：树是一种非线性的数据结构，它模拟层次结构，包括二叉树、二叉搜索树（BST）、平衡树（AVL树）、堆等。树形结构在数据库索引、文件系统等领域有广泛应用。 3. 图数据结构：图由顶点（节点）和连接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值