二叉搜索树

最新推荐文章于 2024-09-21 22:39:48 发布
最新推荐文章于 2024-09-21 22:39:48 发布
阅读量330 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ccDLlyy/article/details/75041876

二叉搜索树可进行查询，插入，删除操作，不是平衡树，平均时间复杂度O(logN)，还可到达O(N)

ACM竞赛也不大常用二叉搜索树，PAT还是常考

实现方法：指针和数组

指针：除了数据结构学习时，竞赛很少用到指针实现

法一：基于C++类封装实现

#include "stdafx.h"
#include <cstdio>
#include <cstring>
#include <iostream>
#include <fstream>
#include <sstream>
using namespace std;
class BST {
private:
	int data;
	BST *left,*right;
public:
	BST(int te):data(te),left(NULL),right(NULL){}
	static void insert(BST *&root,int te) {
		if (root == NULL) {
			root = new BST(te);
		}
		else if(te < root->data){
			insert(root->left, te);
		}
		else {
			insert(root->right, te);
		}
	}
	BST *const &findMin() {
		return this->left == NULL ? this : this->left->findMin();
	}
	void deletes(BST *&root,int te) {
		if (root == NULL) {
			return;
		}
		else if (te < root->data) {
			deletes(root->left, te);
		}
		else if (te > root->data) {
			deletes(root->right, te);
		}
		else if (root->left && root->right) {
			BST * const t = root->right->findMin();
			root->data = t->data;
			deletes(root->right, t->data);
		}
		else {
			BST *t = root;
			if (root->left == NULL) {
				root = root->right;
			}
			else {
				root = root->left;
			}
			delete t;
		}
	}
	void postOrder() {//后序遍历
		if (this->left) {
			this->left->postOrder();
		}
		if (this->right) {
			this->right->postOrder();
		}
		cout << " " << this->data;
	}
	void dispose() {//递归释放内存
		if (this->left) {
			this->left->dispose();
		}
		if (this->right) {
			this->right->dispose();
		}
		delete this;
	}
};
int main() {
	BST *root = NULL;
	int n,te;
	cin >> n;//6
	for (int i = 0; i < n; i++) {//7 6 11 8 12 13
		cin >> te;
		BST::insert(root, te);
	}
	if (root != NULL) {
		root->postOrder();
	}
	cout << endl;
	if (root != NULL) {
		root->deletes(root,11);
	}
	if (root != NULL) {
		root->postOrder();
	}
	cout << endl;
	if (root != NULL) {
		root->dispose();
	}
	return 0;
}

感觉以上不符合C++的封装规则，又改了一下

#include "stdafx.h"
#include <cstdio>
#include <cstring>
#include <iostream>
#include <fstream>
#include <sstream>
using namespace std;
class treeNode {
private:
	int data;
	treeNode *left, *right;
public:
	treeNode(int te):data(te),left(NULL),right(NULL){}
	treeNode *&findMin(treeNode *&root, int te) {
		if (root->left == NULL) {
			return root;
		}
		else
			return findMin(root->left, te);
	}
	treeNode *find(treeNode *root,int te) {
		if (root == NULL || root->data == te) {
			return root;
		}
		return te < root->data ? find(root->left, te) : find(root->right, te);
	}
	static void insert(treeNode *&root, int te) {
		if (root == NULL) {
			root = new treeNode(te);
			return;
		}
		else if (te < root->data) {
			insert(root->left, te);
		}
		else if(te > root->data){
			insert(root->right, te);
		}
		else if (te == root->data) {
			cerr << "ERROR" << endl;
		}
	}
	void deletes(treeNode *&root, int te) {
		if (root == NULL) {
			cerr << "ERROR" << endl;
			return;
		}
		else if (te < root->data) {
			deletes(root->left, te);
		}
		else if (te > root->data) {
			deletes(root->right, te);
		}
		else if(root->left && root->right){
			treeNode *&p = findMin(root->right, te);
			root->data = p->data;
			deletes(root->right, root->data);
		}
		else {
			treeNode *t = root;
			root = root->left == NULL ? root->right : root->left;
			delete t;
		}
	}
	void postOrder(treeNode *&root) {
		if (root == NULL) {
			return;
		}
		postOrder(root->left);
		postOrder(root->right);
		cout << " " << root->data;
	}
	void disPosal(treeNode *&root) {
		if (root->left) {
			disPosal(root->left);
		}
		if (root->right) {
			disPosal(root->right);
		}
		delete root;
	}
};
class BST {
private:
	treeNode *root;
public:
	BST() :root(NULL) {}
	void add(int te) {
		treeNode::insert(root, te);
	}
	void remove(int te) {
		if (root == NULL) {
			cerr << "ERROR" << endl;
			return;
		}
		root->deletes(root,te);
	}
	treeNode *query(int te) {
		if (root == NULL) {
			cerr << "ERROR" << endl;
			return NULL;
		}
		return root->find(root, te);
	}
	void postOrder() {
		if (root == NULL) {
			cerr << "ERROR" << endl;
			return;
		}
		root->postOrder(root);
	}
	void disPosal() {
		if (root == NULL) {
			return;
		}
		root->disPosal(root);
	}
};
int main() {
	int n, te;
	BST bst;
	cin >> n;//6
	for (int i = 0; i < n; i++) {//7 6 11 8 12 13
		cin >> te;
		bst.add(te);
	}
	bst.postOrder();
	cout << endl;
	bst.remove(11);
	bst.postOrder();
	cout << endl;
	bst.disPosal();
	return 0;
}


法二：普通指针实现

#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
//插入和删除函数必须都得以返回指针的形式实现  
//对于插入，看其最后的NULL时插入就能看出  
//对于删除，本质删除的是只有一个儿子和没有儿子的节点，想其删除没有儿子的节点的情况  
//若不返回指针，此节点的父亲就有个指针指向非法区了  
struct TreeNode{  
    int Element;  
    struct TreeNode* Left;  
    struct TreeNode* Right;  
};  
struct TreeNode* Init(){//初始化  
    return NULL;  
}  
void PreTraversal(struct TreeNode* BinSearchTree)//前序遍历    
{    
    if(BinSearchTree!=NULL){    
         printf("%d ",BinSearchTree->Element);    
         PreTraversal(BinSearchTree->Left);    
         PreTraversal(BinSearchTree->Right);    
    }  
    return;    
}    
struct TreeNode* Find(int data,struct TreeNode* BinSearchTree)//查找  
{  
    if(BinSearchTree==NULL)  
        return NULL;  
    else if(BinSearchTree->Left!=NULL&&data<BinSearchTree->Element)  
        return BinSearchTree->Left;  
    else if(BinSearchTree->Right!=NULL&&data>BinSearchTree->Element)  
        return BinSearchTree->Right;  
    else   
        return BinSearchTree;  
}  
struct TreeNode* FindMax(struct TreeNode* BinSearchTree)//查找最大值所在的节点  
{  
    if(BinSearchTree==NULL)  
        return NULL;  
    else if(BinSearchTree->Right!=NULL)  
        return FindMax(BinSearchTree->Right);  
    else  
        return BinSearchTree;  
}  
struct TreeNode* FindMin(struct TreeNode* BinSearchTree)//查找最小值所在的节点  
{  
    if(BinSearchTree==NULL)  
        return NULL;  
    else if(BinSearchTree->Left!=NULL)  
        return FindMin(BinSearchTree->Left);  
    else  
        return BinSearchTree;  
}  
struct TreeNode* Insert(int data,struct TreeNode* BinSearchTree)//插入  
{  
    if(BinSearchTree==NULL){  
        BinSearchTree=(struct TreeNode*)malloc(sizeof(struct TreeNode));  
        BinSearchTree->Element=data;  
        BinSearchTree->Left=NULL;  
        BinSearchTree->Right=NULL;  
        return BinSearchTree;  
    }  
    else if(data<BinSearchTree->Element)  
        BinSearchTree->Left=Insert(data,BinSearchTree->Left);  
    else if(data>BinSearchTree->Element)  
        BinSearchTree->Right=Insert(data,BinSearchTree->Right);  
    else  
        printf("ERROR\n");  
    return BinSearchTree;  
}  
struct TreeNode* Delete(int data,struct TreeNode* BinSearchTree)//删除  
{  
    if(BinSearchTree==NULL)  
        return NULL;  
    else if(data>BinSearchTree->Element)  
        BinSearchTree->Right=Delete(data,BinSearchTree->Right);  
    else if(data<BinSearchTree->Element)  
        BinSearchTree->Left=Delete(data,BinSearchTree->Left);  
    else if(BinSearchTree->Left&&BinSearchTree->Right){//删除有两个孩子的节点，可找左树最大与右树最小代替其，本质删除没有儿子的节点  
        struct TreeNode* Temp=FindMin(BinSearchTree->Right);  
        BinSearchTree->Element=Temp->Element;  
        BinSearchTree->Right=Delete(Temp->Element,BinSearchTree->Right);  
    }  
    else{//删除有一个/零个孩子的节点  
        struct TreeNode* Temp;  
        Temp=BinSearchTree;  
        if(BinSearchTree->Left!=NULL)  
            BinSearchTree=BinSearchTree->Left;  
        else//此处包含了右儿子也为空的情况，即零个孩子  
            BinSearchTree=BinSearchTree->Right;  
        free(Temp);  
    }  
    return BinSearchTree;  
  
}  
int main(){  
    struct TreeNode* BinSearchTree;  
    //初始化  
    BinSearchTree=Init();  
    //插入  
    BinSearchTree=Insert(4,BinSearchTree);  
    BinSearchTree=Insert(3,BinSearchTree);  
    BinSearchTree=Insert(6,BinSearchTree);  
    BinSearchTree=Insert(5,BinSearchTree);  
    BinSearchTree=Insert(7,BinSearchTree);  
    BinSearchTree=Insert(2,BinSearchTree);  
    //遍历一遍，便于检验代码  
    PreTraversal(BinSearchTree);  
    putchar('\n');  
    //删除有零个孩子的2节点  
    BinSearchTree=Delete(2,BinSearchTree);  
    PreTraversal(BinSearchTree);  
    putchar('\n');  
    //重新插入2  
    BinSearchTree=Insert(2,BinSearchTree);  
    //删除有一个孩子的3节点  
    Delete(3,BinSearchTree);  
    PreTraversal(BinSearchTree);  
    putchar('\n');  
    //删除有两个孩子的6节点  
    Delete(6,BinSearchTree);  
    PreTraversal(BinSearchTree);  
    putchar('\n');  
      
}


数组实现：

法一：基于C++类封装实现

#include "stdafx.h"
#include <cstdio>
#include <cstring>
#include <iostream>
#include <fstream>
#include <sstream>
#include <queue>
using namespace std;
#define MAXN 100005
class BST {
private:
	int len,root;
	int data[MAXN], left[MAXN], right[MAXN], book[MAXN];
public:
	BST(int te) :len(te),root(-1){
		memset(left, -1, sizeof(left));
		memset(right, -1,sizeof(right));
		memset(book, 0, sizeof(book));
	}
	void insert(int &root, int i) {//执行插入操作
		if (root == -1) {
			root = i;
			return;
		}
		if (data[i] < data[root]) {
			insert(left[root], i);
		}
		else {
			insert(right[root], i);
		}
	}
	void buildTree() {//建树
		for (int i = 0; i < len; i++) {
			cin >> data[i];
			book[i] = 1;
			insert(root, i);
		}
	}
	int query(int te) {//查询当前值的下标
		for (int i = 0; i < len; i++) {
			if (book[i] && data[i] == te) {
				return i;
			}
		}
		return -1;
	}
	void add(int te) {//增添数据
		if (query(te) != -1) {
			return;
		}
		data[len++] = te;
		insert(root, len-1);
	}
	int findMin(int i) {//查找当前节点以及其子树的最小值的下标
		if (left[i] == -1) {
			return i;
		}
		return findMin(left[i]);
	}
    void deletes(int &root, int te) {//执行删除操作
		if (root == -1) {
			return;
		}
		else if (te < data[root]) {
		    deletes(left[root], te);
		}
		else if (te > data[root]) {
			deletes(right[root], te);
		}
		else if(left[root] != -1 && right[root] != -1){
			int index = findMin(right[root]);
			data[root] = data[index];
			deletes(right[root], data[root]);
		}
		else {
			root = left[root] == -1?right[root]:left[root];
			book[root] = 0;
		}
	}
	void remove(int te) {//删除数据
		deletes(root, te);
	}
	void levelOrder() {//层序遍历
		queue<int> q;
		q.push(root);
		while (!q.empty()) {
			int t = q.front();
			cout << " " << data[t];
			q.pop();
			if (left[t] != -1) {
				q.push(left[t]);
			}
			if (right[t] != -1) {
				q.push(right[t]);
			}
		}
		cout << endl;
	}
};
int main() {
	int te,n;
	BST *tree;
	while (scanf("%d", &n) != EOF) {
		tree = new BST(n);
		tree->buildTree();
		tree->add(3);
		tree->remove(3);
		tree->levelOrder();
		delete tree;
	}
	return 0;
}


法二：普通实现

#include "stdafx.h"
#include <cstdio>
#include <cstring>
#include <iostream>
#include <fstream>
#include <sstream>
#include <queue>
using namespace std;
#define MAXN 100005
int data[MAXN], left[MAXN], right[MAXN],book[MAXN];
int root, len;
void insert(int &root, int i) {
	if (root == -1) {
		root = i;
		return;
	}
	if (::data[i] < ::data[root]) {
		insert(::left[root], i);
	}
	else {
		insert(::right[root], i);
	}
}
int findMin(int root) {
	if (::book[root] && ::left[root] == -1) {
		return root;
	}
	return findMin(::left[root]);
}
void deletes(int &root, int te) {
	if (root == -1) {
		return;
	}
	else if (te < ::data[root]) {
		deletes(::left[root], te);
	}
	else if (te > ::data[root]) {
		deletes(::right[root], te);
	}
	else if (::left[root] != -1 && ::right[root] != -1) {
		int index = findMin(::right[root]);
		::data[root] = ::data[index];
		deletes(::right[root], ::data[root]);
	}
	else {
		root = ::left[root] == -1 ? ::right[root]: ::left[root];
		::book[root] = 0;
	}
}
void levelOrder() {
	queue<int> q;
	q.push(root);
	while (!q.empty()) {
		int t = q.front();
		q.pop();
		cout << " " << ::data[t];
		if (::left[t] != -1) {
			q.push(::left[t]);
		}
		if (::right[t] != -1) {
			q.push(::right[t]);
		}
	}
	cout << endl;
}
int main() {
	int te;
	while (scanf("%d", &len) != EOF) {
		root = -1;
		memset(::left, -1, sizeof(::left));
		memset(::right, -1, sizeof(::right));
		memset(::book, 0, sizeof(::book));
		for (int i = 0; i < len; i++) {
			cin >> ::data[i];
			::book[i] = 1;
			insert(root, i);
		}
		::data[len++] = 4;
		insert(root, len - 1);
		deletes(root, 4);
		levelOrder();
	}
	return 0;
}



Splay树(伸展树)
不忘初心
07-23 1206
伸展树（Splay Tree），是一种二叉平衡搜索树，时间复杂度均摊为O(logN)，即splay树做m次操作的复杂度为O(mlogN)。 在伸展树上的一般操作都基于伸展操作/提根操作： 假设想要对一个二叉搜索树执行一系列的查找操作，为了使整个查找时间更小，被查频率高的那些条目就应当经常处于靠近树根的位置。于是想到设计一个简单方法， 在每次查找之后对树进行重构，把被查找的条目搬移到离树根近
数据结构：二叉查找树
勤学如春起之苗，不见其增，日有所长！ 辍学如磨刀之石，不见其损，日有所亏！
12-25 166
定义 二叉查找树是一棵特殊的二叉树，它在二叉树的基础上附加了该性质：对于树中的每个结点X，它的左子树中所有关键字都小于或等于X的关键字，而它的右子树中所有关键字都大于或等于X的关键字。如下图所示： 查找树的设计目标都是减少最坏情况下单次操作的时间，但是由于查找树的典型应用经常需要执行一系列的查找操作，因此此时更关心的性能指标是所有这些操作总共需要多少时间。对于此类应用，更好的目标就是降低...
二叉搜索树（BST，基本操作实现）
sgh666666的博客
12-12 515
二叉搜索树（Binary Search Tree)也叫做二叉排序树或者二叉查找树。 相比正常的二叉树就是多了一条性质：左子树的键值小于其根节点的键值，右子树反之，左右子树都是二叉搜索树。 主要操作函数：（还是递归递归递归！！！） Position Find( ElementType X, BinTree BST )：从二叉搜索树BST 中查找元素X，返回其所在结点的地址； Posi
超全C语言二叉树基本操作及讲解
疾风剑豪
04-20 1434
今天刷LeetCode上的题的时候，做到了关于二叉树的题，于是决定把这一块的知识整理一下。 1、二叉树的定义 二叉树通常以结构体的形式定义，如下，结构体内容包括三部分：本节点所存储的值、左孩子节点的指针、右孩子节点的指针。这里需要注意，子节点必须使用指针，就像我们定义结构体链表一样，下一个节点必须使用地址的方式存在在结构体当中。 struct TreeNode { int va...
Codeup——611 | 问题 D: 二叉树遍历
qq_44888152的博客
10-12 631
题目描述 编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。 输入 输入包括1行字符串，长度不超过100。 输出 可能有多组测试数据，对于每组数据， 输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。 每个输出结果占一行。 样例输入 a#b#cdef##### a## 样例输出 a b
二叉搜索树详解
2302_79215415的博客
06-25 2244
但对于有n个节点的二叉搜索树，若每个元素的概率相等，则二叉搜索树的平均查找长度是节点在二叉搜索树的深度的函数，节点越深，比较次数就越多。所有在“大佬“的改进下，我们有引入的平衡二叉树和红黑树的概念，使得二叉树的性能有了较大的提升，下一篇内容将会给大家介绍平衡二叉数。2、统计单词的次数，给定一个单词的拼写，就可以快速找到其出现的次数单词由其出现次数就是的一种键值对。情况d、在它的右子树中寻找中序下的第一个节点，用它 的值填补到被删除节点中，再去处理该节点的删除问题----替换删除。
二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
热门推荐
weixin_54186646的博客
04-25 10万+
图解二叉排序树（二叉查找树、二叉搜索树）的插入操作、查找操作、删除操作以及完整的代码实现
C++：二叉搜索树
最新发布
HZzzzzLu的博客
09-21 1711
一文带你理解二叉搜索树
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
c代码-二叉搜索树的删除操作
07-14
在IT领域，二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据结构，它具有很多优秀的特性，比如快速的查找、插入和删除操作。在实际应用中，我们经常需要对BST进行各种操作，其中删除操作是相对复杂的一个...
树-98. 验证二叉搜索树-PYTHON
01-20
在二叉搜索树（Binary Search Tree，BST）中，每个节点的值必须满足以下规则：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。在给定的题目“树-98. 验证...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
2017百度之星资格赛 1002 度度熊的王国战略(并查集 or 无向图最小割)
不忘初心
08-07 1085
题目链接：点击打开链接 题意很容易理解，基本上这个题意就是让你去考虑无向图的最小割，无奈只会用模版，还没想好怎么用堆优化Stoer-Wagner算法，TLE......而且百度把这题的时间放宽到了2000ms，这样还超时，不会优化真尴尬......SW算法用堆优化一般适用于稀疏图，如果是稠密图，优化还可能更费时，看此题的数据，点的个数取值为3 * 10^3，边的个数为10^5，应该是稀疏图的测试
并查集的写法
不忘初心
03-27 1072
法一： int fa[MAXN+1]; void Init(int n){ for(int i=1;i<=n;i++){ fa[i]=i; } } int GetFather(int x){ return fa[x]=(fa[x]==x?x:GetFather(fa[x])); } void Merge(int x,int y){ int a=Get(x); int b=Get(y
左偏树
不忘初心
07-12 1030
左偏树(Leftist Tree)是一种可并堆(Mergeable Heap) ，它除了支持优先队列的三个基本操作（插入，删除，取最小节点），还支持一个很特殊的操作——合并操作 左偏树是一棵二叉树，它的节点除了和二叉树的节点一样具有左右子树指针( left, right)外，还有两个属性：键值和距离(dist)。键值是用于比较节点的大小。距离则是如下定义的：  节点i称为外节点(ext
AVL树(一种二叉平衡搜索树)
不忘初心
01-21 897
普通的二叉搜索树,深度不一定为为O(logn),那么则是不平衡的 如果不进行删除操作或进行极少的删除操作(可利用懒惰删除),提出一种解决方案,即AVL Tree,任意节点左右子树的高度差绝对值不超过1,规定空树的高度为-1,即一个单独节点的高度为0 当进行插入操作,插入过程同二叉搜索树,插入后,插入路径上节点的平衡可能遭到破坏,从插入点到根结点的路径上(即自下而上)找到第一个失去平衡的节点
山东省第六届ACM竞赛 山东理工SDUT3258 Square Number
不忘初心
04-30 850
Problem Description In mathematics, a square number is an integer that is the square of an integer. In other words, it is the product of some integer with itself. For example, 9 is a square number,
二叉搜索树中的搜索算法详解
根据给定的信息，我们可以确定本篇知识点的核心集中在二叉搜索树（Binary Search Tree，简称BST）以及在二叉搜索树中进行搜索的相关内容。为了满足字数要求并提供丰富的信息，下面将对二叉搜索树的概念、特点、搜索...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值