BST的基本操作

// BST.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <malloc.h>
#include <stdlib.h>
#include <vector>
using namespace std;


typedef struct TreeNode
{
	int val;
	TreeNode *leftChild;
	TreeNode *rightChild;
	TreeNode *parent;
}TreeNode;

void TreeInsert(TreeNode **t, int nodeVal)
{
	TreeNode *p = (TreeNode *)malloc(sizeof(TreeNode));
	p->val = nodeVal;
	p->leftChild = NULL;
	p->rightChild = NULL;
	p->parent = NULL;
	if (*t == NULL)
	{
		*t = p;
		return;
	}
	if (((*t)->leftChild == NULL) && ((*t)->val > nodeVal))
	{
		p->parent = *t;
		(*t)->leftChild = p;
		return;
	}
	if ((*t)->rightChild == NULL && (*t)->val < nodeVal)
	{
		p->parent = *t;
		(*t)->rightChild = p;
		return;
	}
	if ((*t)->val > nodeVal)
	{
		TreeInsert(&((*t)->leftChild), nodeVal);
	}
	else
	{
		TreeInsert(&((*t)->rightChild), nodeVal);
	}
	return;
}

//层序遍历打印二叉树
void PrintTree(TreeNode * p)
{
	if (NULL == p)
	{
		return;
	}
	vector<TreeNode*> vec;
	vec.push_back(p);
	int cur = 0;
	int last = 0;
	while (cur < vec.size())
	{
		last = vec.size();
		while (cur < last)
		{
			cout << vec[cur]->val << "  ";
			if (NULL != vec[cur]->leftChild)
			{
				vec.push_back(vec[cur]->leftChild);
			}
			if (NULL != vec[cur]->rightChild)
			{
				vec.push_back(vec[cur]->rightChild);
			}
			cur++;
		}
		cout << endl;
	}

}

//先序遍历二叉树
void preOrderTraverse(TreeNode * root)
{
	if (root)
	{
		cout << root->val<<" ";
		preOrderTraverse(root->leftChild);
		preOrderTraverse(root->rightChild);
	}
}

//中序遍历二叉树
void inOrderTraverse(TreeNode *root)
{
	if (root)
	{
		preOrderTraverse(root->leftChild);
		cout << root->val;
		preOrderTraverse(root->rightChild);
	}
}
//后序遍历
void postOrderTraverse(TreeNode *root)
{
	if (root)
	{
		preOrderTraverse(root->leftChild);
		preOrderTraverse(root->rightChild);
		cout << root->val;
	}
}
//二叉树删除节点
bool deleteNode(TreeNode *root, int value)
{
	bool delete_result = false;//删除是否成功
	TreeNode *p = root;
	//首先搜索树中是否存在该节点
	while (p != NULL && !delete_result)
	{
		if (p->val == value)
		{
			delete_result = true;
		}
		else if (value < p->val)
		{
			p = p->leftChild;
		}
		else
		{
			p = p->rightChild;
		}
	}
	if (NULL == p)
	{
		cout << "BST 中不存在要删除的节点" << endl;
		return delete_result;
	}
	//找到了要删除的节点
	//1.该节点为叶子节点，即没有左右子树
	if (p->leftChild == NULL && p->rightChild == NULL)
	{
		if (p == root)
			root = NULL;
		else if(p->parent->leftChild == p)
		{
			p->parent->leftChild = NULL;
		}
		else if (p->parent->rightChild == p)
		{
			p->parent->rightChild = NULL;
		}
	}
	//2.该节点只有左孩子节点，删除该节点，并使该节点的父节点指向该节点的左孩子节点
	if (p->leftChild != NULL && p->rightChild == NULL)
	{
		p->parent->leftChild == p->leftChild;
	}
	//3.该节点只有右孩子节点，删除该节点，并使该节点的父节点指向该节点的右孩子节点
	if (p->leftChild == NULL && p->rightChild != NULL)
	{
		p->parent->rightChild == p->rightChild;
	}
	//4.要删除的节点有左右节点，找删除节点左子树的最大节点或者右子树的最小节点替换被删除的节点
	//然后删除左子树的最大节点或者右子树的最小节点.此处使用左子树的最大节点替换。
	if (p->leftChild && p->rightChild)
	{
		TreeNode *temp = p->leftChild;
		temp->leftChild = p->leftChild->leftChild;
		while (temp->rightChild)
		{
			temp = temp->rightChild;
		}
		p->val = temp->val;
		//如果左子树最大节点是其父节点的左子树
		if (temp->parent->leftChild == temp)
		{
			if (temp->leftChild == NULL)
				temp->parent->leftChild;
			else
				temp->parent->leftChild = temp->leftChild;
		}
		//如果左子树最大节点是其父节点的右子树
		if (temp->parent->rightChild == temp)
		{
			if (temp->rightChild = NULL)
				temp->parent->rightChild = NULL;
			else
				temp->parent->rightChild = temp->rightChild;
		}
		delete temp;

	}
}

//查找最小关键字
TreeNode * minSearch(TreeNode * root)
{
	if (root == NULL)
		return NULL;
	while (root->leftChild != NULL)
		root = root->leftChild;
	return root;
}

//查找最大关键字
TreeNode * maxSearch(TreeNode * root)
{
	if (root == NULL)
		return root;
	while (root->rightChild != NULL)
	{
		root = root->rightChild;
	}
	return root;
}

//查找元素,找到返回关键字的结点指针，没找到返回NULL  
TreeNode* search( TreeNode * root, int  key)
{
	if (root == NULL)
		return NULL;
	if (key > root->val) //查找右子树  
		return search(root->rightChild, key);
	else if (key < root->val) //查找左子树  
		return search(root->leftChild, key);
	else if(key == root->val)
		return root;
}


int main()
{
	TreeNode *root = NULL;
	int a[] = {20,30,35,8,15,25,24,10};
	int length = 8;
	for (int i = 0;i < length;i++)
	{
		TreeInsert(&root, a[i]);
	}
	//PrintTree(root);
	preOrderTraverse(root);
	TreeNode *find_res = search(root, 78);
	if (find_res != NULL)
	{
		cout << find_res->val;
	}
	else
	{
		cout << "二叉树中不存在该节点 ！" << endl;
	}
	TreeNode *res_min = minSearch(root);
	TreeNode *res_max = maxSearch(root);
	if (res_min != NULL)
	{
		cout << res_min->val<<endl;
	}
	if (res_max != NULL)
	{
		cout << res_max->val << endl;
	}
	deleteNode(root, 30);
	PrintTree(root);
	
	int b;
	cin >> b;


}

最后

以上就是难过月光为你收集整理的BST的基本操作的全部内容，希望文章能够帮你解决BST的基本操作所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。