二叉搜索树

二叉搜索树是一种有序二叉树,通过对其中序遍历,可以得到一组非递减的数据。如下图所示的一颗二叉搜索树,中序遍历后得到的数组是 8、10、11、12、15、18。二叉搜索树的基本性质:左子树<=根<=右子树,查询的时间复杂度为O(lg(n))。

在实际编写代码时,定义一个结点的数据结构和一个二叉搜索树的数据结构,以及一些基本方法。

typedef struct Node
{
	int value;
	int size;
	struct Node *parent;
	struct Node *left;
	struct Node *right;
} Node;

typedef struct Tree
{
	Node *root;
} Tree;
Node *createNode(int value)
{
	Node *node = (Node *)malloc(sizeof(Node));
	node->left = NULL;
	node->right = NULL;
	node->parent = NULL;
	node->value = value;
	node->size = 1;
	return node;
}
Tree* initTree()
{
	Tree *tree = (Tree *)malloc(sizeof(Tree));
	tree->root = NULL;
	return tree;
}
createNode是创建一个新结点的方法。initTree是初始化一颗二叉搜索树的方法。Node是一个结点的结构,其中value为结点的值,size为该结点下的子树的结点总数(包括自己)。Tree是一颗二叉搜索树的结构,其拥有一个树根root成员。

1. 二叉搜索树的插入

在二叉搜索树中插入一个指定值的结点,只需要从树根向下找到合适的位置插入为叶子结点即可。该过程会形成一条从根到被插入结点的唯一路径。在向下遍历时,如果要插入的值比结点的值小,则向结点的左子树遍历,否则向右子树遍历,如此循环即可。插入的代码如下所示。

void insertBinarySearchTree(Tree *tree, int value)
{
	if (tree->root == NULL)
	{
		tree->root = createNode(value);
		return;
	}

	Node *node = createNode(value);
	Node *n = tree->root;
	while (1)
	{
		n->size++;
		if (value < n->value)
		{
			if (n->left == NULL)
			{
				n->left = node;
				node->parent = n;
				break;
			}
			n = n->left;
		}
		else
		{
			if (n->right == NULL)
			{
				n->right = node;
				node->parent = n;
				break;
			}
			n = n->right;
		}
	}
}

2. 二叉搜索树结点的删除

从一颗二叉搜索树中删除结点x有3种情况:

(1) x是叶子结点,则直接删除;

(2) x有一个孩子结点(左孩子或者右孩子),则直接将x的父结点指向孩子,如果x是根结点,则要更新树根;

(3) x有两个孩子结点,则要找到x在右子树中的后驱结点y,然后将y的父结点的左子树指向y的右子树,再用y替换掉x。

第三种情况可能有点难理解。先解释一下什么叫后驱。一个结点s的后驱结点是指:在中序遍历时,排在x的值的后面的结点,称之为x的后驱结点。也就是说,后驱结点是大于x的结点中的最小结点,也就是x的右子树中的最小结点,即x的右子树中最左侧的不拥有左子树结点。因此,我们需要有这样一个方法来辅助寻找结点x的后驱结点。

Node* minimum(Tree *tree)
{
	Node *n = tree->root;
	if (n == NULL)	return NULL;
	while (n->left != NULL)	n = n->left;
	return n;
}
minimum方法可以找到一棵树中的最小的结点,方法很简单,就是一直向左遍历知道没有左子树为止。使用minimum方法可以找到一个结点x的后驱结点:

Tree t;
t.root = x->right;
Node *back = minimum(&t);
结点back就是x的后驱结点。

再来思考一下删除一个有两个孩子的结点x的情况,考虑中序遍历的数组,删除了x的值,他的位置就会被x的后驱顶上,于是就有情况(3)中所说的用后驱替换结点x的操作,这样就相当于不删除结点x,而是删除x的后驱结点,而x的后驱结点又是一个只有右孩子的结点,于是就只需要对它做情况(2)的操作即可。

情况(3)的操作具体如下图所示。

上图中删除结点10,符合情况(3),于是先找到结点10的后驱结点,即结点10的右子树的最小结点,即结点11,然后将结点11的父结点13的左子树指向结点11的右子树12,最后用结点11替换掉结点10,便得到了右图。

在实际编程中,我们使用一个transplant方法来通过移植树达到删除/替换结点的目的。

/**
* 将*tree1替换成tree2,若*tree1为根,则直接改变tree->root指向
*/
void transplant(Tree *tree, Node *tree1, Node *tree2)
{
	if (tree1->parent == NULL)
	{
		tree->root = tree2;
		tree2->parent = NULL;
		return;
	}

	if (tree2 != NULL)					tree2->parent = tree1->parent;
	if (tree1 == tree1->parent->left)	tree1->parent->left = tree2;
	else								tree1->parent->right = tree2;
}
transplant方法将一颗二叉搜索树tree中的tree1子树替换成tree2。

删除结点的代码如下所示。

void deleteFromBinarySearchTree(Tree *tree, Node *node)
{
	if (node == NULL)	return;

	Node *n = node;
	while (n->parent != NULL)
	{
		n = n->parent;
		n->size--;
	}

	if (node->left == NULL)
	{
		transplant(tree, node, node->right);
	}
	else if (node->right == NULL)
	{
		transplant(tree, node, node->left);
	}
	else
	{
		Tree t;
		t.root = node->right;
		Node *min = minimum(&t);
		Node *end = min->right;
		min->size = node->size - 1;
		if (node == tree->root)	tree->root = min;

		if (node->right != min)
		{
			transplant(tree, min, min->right);
			min->right = node->right;
			node->right->parent = min;
		}
		min->left = node->left;
		node->left->parent = min;
		transplant(tree, node, min);
		
		n = min->right;
		while (n != end)
		{
			n->size--;
			n = n->left;
		}
	}

	free(node);
}
删除结点首先从被删除结点开始,向上调整结点的size,然后再一次判断3中情况并做响应操作。针对情况(3),程序还需要对   被删除结点x   到   实际被删除的x的后驱结点min的父结点   的路径上的结点调整size。

3. 中序遍历

可以使用递归来实现中序遍历。

void inOrder(Tree *tree, int **order, int *num)
{
	*num = tree->root->size;
	*order = (int *)malloc(sizeof(int) * *num);
	int i = 0;
	inOrder(tree->root, order, &i);
}

void inOrder(Node *node, int **order, int *i)
{
	if (node == NULL)
	{
		return;
	}

	inOrder(node->left, order, i);
	(*order)[*i] = node->value;
	(*i)++;
	inOrder(node->right, order, i);
}

4. 总结

二叉搜索树的插入操作的平均时间复杂度为O(lg(n))。

删除操作如果忽略对size的调整,其无非就是一个修改指针指向的操作,因此其可以在常数时间内完成。

二叉搜索树有一个很大的缺点,如果将一组非递减的数据依次执行插入操作来构造二叉搜索树,那么最后构造出来的只是一个单链表,其查询操作的时间复杂度为O(n)。虽然我们可以通过采取随机构建的方法(即从数组中随机抽取数据执行插入操作)来尽量避免这一种情况,但是实际情况下构造出来的二叉搜索树都不一定很优。于是我们就需要对此作出改进。改进的结果有很多,如AVL树、红黑树等。

AVL树可以参考AVL树的插入与删除

红黑树可以参考红黑树的插入与删除

代码可以参考我github上的数据结构与算法

大家感兴趣的可以fork一下,也可以顺便关注一下O(∩_∩)O~

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页