二叉排序树

性质：

二叉排序树又叫二叉搜索树，具有以下性质：

若左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值；
若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；
左、右子树也分别为二叉排序树；

如下就是一颗二叉排序树：

中序遍历的结果正好是1 3 5 7 8。

结构体定义：

typedef int BSTreeDataType;

// 二叉搜索树（二叉排序树）
typedef struct BSTreeNode {
	BSTreeDataType data;
	struct BSTreeNode* LChild;
	struct BSTreeNode* RChild;
}BSTreeNode;

对于二叉排序树有以下几个操作：

插入节点
搜索节点
删除节点
销毁二叉搜索树
遍历二叉搜索树

插入节点，时间复杂度：log2(N)（对于非单只树）。

第一步：找到节点

判断当前节点数据（curData）和要插入的节点的数据（insertData）比较，相等不插入，如果

insertData<curData 在左子树找，如果insertData > curData在右子树找。并记录父节点。

第二步：插入

如果小于父节点插入parrent->LChild = insertNode；否则parrent->RChild = insertNode；

代码如下：

递归：

// 插入节点，递归插入
int insertBSTreeNode(BSTreeNode** pRoot, BSTreeDataType data) {
	if (*pRoot == NULL) {
		*pRoot = buyBSTreeNode(data);
		return 1;
	}
	if ((*pRoot)->data == data)
		return 0;
	if ((*pRoot)->data > data) {
		return insertBSTreeNode(&(*pRoot)->LChild, data);
	}
	return insertBSTreeNode(&(*pRoot)->RChild, data);
}

非递归：

// 非递归插入节点，返回插入状态
int insertBSTreeNodeNor(BSTreeNode** pRoot, BSTreeDataType data) {
	BSTreeNode* insertNode = buyBSTreeNode(data);
	if (*pRoot == NULL) {
		*pRoot = insertNode;
		return 1;
	}

	BSTreeNode* Cur = *pRoot;
	BSTreeNode* preCur = NULL;
	while (Cur) {
		if (Cur->data == data) {
			return 0;
		}
		else if (data < Cur->data) {
			preCur = Cur;
			Cur = Cur->LChild;
		}
		else if (data > Cur->data) {
			preCur = Cur;
			Cur = Cur->RChild;
		}
	}
	if (data > preCur->data) {
		preCur->RChild = insertNode;
	}
	else {
		preCur->LChild = insertNode;
	}
}

搜索节点, 时间复杂度：log2(N)

步骤：判断当前节点数据（curData）和要插入的节点的数据（insertData）比较，相等直接返回，如果

insertData < curData 在左子树找，如果insertData > curData在右子树找。

代码如下：

// 递归搜索节点
BSTreeNode* findBSTreeNode(BSTreeNode* pRoot, BSTreeDataType data) {
	if (pRoot == NULL)
		return NULL;
	if (pRoot->data == data) {
		return pRoot;
	}

	if (data < pRoot->data) {
		return findBSTreeNode(pRoot->LChild, data);
	}

	return findBSTreeNode(pRoot->RChild, data);
}

// 非递归搜索节点
BSTreeNode* findBSTreeNodeNor(BSTreeNode* pRoot, BSTreeDataType data) {
	if (pRoot == NULL)
		return NULL;
	BSTreeNode* Cur = pRoot;
	while (Cur) {
		if (Cur->data == data) {
			return Cur;
		}
		else if (data > Cur->data) {
			Cur = Cur->RChild;
		}
		else if (data < Cur->data) {
			Cur = Cur->LChild;
		}
	}
	return NULL;
}

删除节点，时间复杂度：

删除节点分为以下几个状态：

删除的节点为叶子节点：直接删除

删除的节点为根节点：

|__________根节点只有右孩子

|__________根节点只有左孩子

|__________跟节点左右孩子都有

|______方式1：找到根节点右孩子的最左孩子，将这个节点的值赋值给根节点，删除这个节点

|______方式2：找到根节点左孩子的最右孩子，将这个节点的值赋值给根节点，删除这个节点

删除的节点为父节点的左孩子

如果删除的节点有右孩子，和删除根节点的方式一样。

如果删除的节点无右孩子，让父节点的LChild = delNode->LChild；

删除的节点为父节点的右孩子

如果删除的节点有左孩子，和删除根节点的方式一样。

如果删除的节点无右孩子，让父节点的RChild = delNode->RChild；

代码如下：

// 删除节点
void deleteBSTreeNode(BSTreeNode** pRoot, BSTreeDataType data) {
	// 找到节点
	BSTreeNode* Cur = *pRoot;
	BSTreeNode* preCur = NULL;
	while (Cur) {
		if (Cur->data == data)
			break;
		else if (data < Cur->data) {
			preCur = Cur;
			Cur = Cur->LChild;
		}
		else if (data > Cur->data) {
			preCur = Cur;
			Cur = Cur->RChild;
		}
	}

	if (Cur == NULL)
		return;

	BSTreeNode* delNode = Cur;

	// 如果删除的是叶子节点
	if (delNode->RChild == NULL && delNode->LChild == NULL) {
		if (delNode == preCur->LChild) {
			free(delNode);
			delNode = NULL;
			preCur->LChild = NULL;
			return;
		}
		if (delNode == preCur->RChild) {
			free(delNode);
			delNode = NULL;
			preCur->RChild = NULL;
			return;
		}
	}

	//如果删除的节点是根节点
	if (delNode == *pRoot) {
		if (delNode->LChild == NULL) {
			// 如果根节点无左孩子
			delNode = *pRoot;
			*pRoot = (*pRoot)->RChild;
			free(delNode);
			delNode = NULL;
		}
		else if (delNode->RChild == NULL) {
			// 如果根节点无右孩子
			delNode = *pRoot;
			*pRoot = (*pRoot)->LChild;
			free(delNode);
			delNode = NULL;
		}
		else {
			// 如果根节点有左右孩子
			// 让根节点和右孩子的最左孩子交换,然后删除这个最左孩子
			// 找到右孩子的最左孩子
			delNode = (*pRoot)->RChild;
			while (delNode->LChild) {
				preCur = delNode;
				delNode = delNode->LChild;
			}

			// 将最左孩子值赋值给根节点
			(*pRoot)->data = delNode->data;

			// 删除这个节点
			if (delNode->RChild != NULL) {
				// 如果要删除的节点有右孩子
				if (preCur != NULL)
					preCur->LChild = delNode->RChild;
				else {
					(*pRoot)->RChild = delNode->RChild;
				}
				free(delNode);
				delNode = NULL;
			}
			else {
				free(delNode);
				delNode = NULL;
				preCur->LChild = NULL;
			}
		}
	}
	else if (delNode == preCur->LChild) {
		// 如果删除的节点是父节点的左孩子
		if (delNode->LChild == NULL) {
			// 如果删除的节点无左孩子
			preCur->LChild = delNode->RChild;
			free(delNode);
			delNode = NULL;
		}
		else if (delNode->RChild == NULL) {
			// 如果删除的节点无右孩子
			preCur->LChild = delNode->LChild;
			free(delNode);
			delNode = NULL;
		}
		else {
			// 如果删除的节点有左右孩子

			// 找到右孩子的最左孩子
			delNode = Cur->RChild;

			// 如果右孩子无左孩子
			if (delNode->LChild == NULL) {
				Cur->data = delNode->data;
				Cur->RChild = delNode->RChild;
				free(delNode);
				delNode = NULL;
				return;
			}

			// 如果右孩子有左孩子，找到最左孩子
			while (delNode->LChild) {
				preCur = delNode;
				delNode = delNode->LChild;
			}
			

			// 将最左孩子值赋值给根节点
			Cur->data = delNode->data;

			// 删除这个节点
			if (delNode->RChild != NULL) {
				// 如果要删除的节点有右孩子
				preCur->LChild = delNode->RChild;
				free(delNode);
				delNode = NULL;
			}
			else {
				free(delNode);
				delNode = NULL;
				preCur->LChild = NULL;
			}
		}
	}

	else if (delNode == preCur->RChild) {
		// 如果删除的节点是父节点的右孩子
		if (delNode->LChild == NULL) {
			// 如果删除的节点无左孩子
			preCur->RChild = delNode->RChild;
			free(delNode);
			delNode = NULL;
		}
		else if (delNode->RChild == NULL) {
			// 如果删除的节点无右孩子
			preCur->RChild = delNode->LChild;
			free(delNode);
			delNode = NULL;
		}
		else {
			// 如果删除的节点有左右孩子

			// 找到左孩子的最右孩子
			delNode = Cur->LChild;

			// 如果左孩子无右孩子
			if (delNode->RChild == NULL) {
				Cur->data = delNode->data;
				Cur->LChild = delNode->LChild;
				free(delNode);
				delNode = NULL;
				return;
			}

			// 如果左孩子有右孩子，找到最右孩子
			while (delNode->RChild) {
				preCur = delNode;
				delNode = delNode->RChild;
			}

			// 将最右孩子值赋值给根节点
			Cur->data = delNode->data;

			// 删除这个节点
			if (delNode->LChild != NULL) {
				// 如果要删除的节点有左孩子
				preCur->RChild = delNode->LChild;
				free(delNode);
				delNode = NULL;
			}
			else {
				free(delNode);
				delNode = NULL;
				preCur->RChild = NULL;
			}
		}
	}
}

中序遍历二叉排序树（和二叉树的操作一样）：

// 中序遍历二叉树
void inOrderBSTree(BSTreeNode* pRoot) {
	if (pRoot != NULL) {
		inOrderBSTree(pRoot->LChild);
		printf("%d ", pRoot->data);
		inOrderBSTree(pRoot->RChild);
	}
}

销毁二叉排序树（和二叉树的操作一样）：

// 销毁二叉排序树
void destroyBSTreeNode(BSTreeNode** pRoot) {
	// 后续遍历规则
	if (*pRoot != NULL) {
		destroyBSTreeNode(&(*pRoot)->LChild);
		destroyBSTreeNode(&(*pRoot)->RChild);
		free(*pRoot);
		*pRoot = NULL;
	}
}

主函数调用：

int main() {
	BSTreeNode* pRoot = NULL;
	BSTreeDataType arr[] = {7, 11, 3, 1, 5, 9, 12, 4, 6, 8, 10};
	int len = sizeof(arr) / sizeof(arr[0]);
	
	for (int i = 0; i < len; i++) {
		insertBSTreeNodeNor(&pRoot, arr[i]);
	}
	printf("插入所有节点成功！\n");
	printf("中序遍历二叉排序树：\n");
	inOrderBSTree(pRoot);
	// 搜索节点
	BSTreeNode* node = findBSTreeNode(pRoot, 7);
	printf("\n找到并删除节点%d\n", node->data);
	deleteBSTreeNode(&pRoot, node->data);
	printf("中序遍历二叉排序树：\n");
	inOrderBSTree(pRoot);
	// 销毁二叉树
	printf("\n销毁之后中序遍历二叉排序树：\n");
	destroyBSTreeNode(&pRoot);
	inOrderBSTree(pRoot);
	return 0;
}

测试用例：

7, 11, 3, 1, 5, 9, 12, 4, 6, 8, 10

运行结果：