二叉搜索树

最新推荐文章于 2023-01-09 15:27:08 发布
最新推荐文章于 2023-01-09 15:27:08 发布
阅读量227 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 自定义栈 自定义队列 后序非递归遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wayofthinking/article/details/56835060
版权

二叉树T：一个又穷的结点集合

（这个集合可以为空，若不为空，则它是由根节点和称其左子树TL和右子树TR的两个不相交的二叉树组成）


使用结构体定义树的结点：

struct node
{
	DataType data;
	struct node *left, *right;
};
typedef struct node *BiTree;


开辟一个新结点 (返回这个结点的地址) (总是被Insert函数调用)： 
BiTree newNode(DataType d)
{
	BiTree n = (BiTree)malloc(sizeof(struct node));
	n->data = d;
	n->left = n->right = NULL;
	return n;
}
定义Insert函数，在树中加入一个结点
（规则：二叉搜索树，左子结点的值比根节点值小，右子结点的值比根节点值大） 
BiTree Insert(BiTree node, DataType d)
{
	if(!node)
		node = newNode(d);		// 结点的value 
	else
	{
		if(d >= node->data)
			node->right = Insert(node->right, d);
		else
			node->left = Insert(node->left, d);
	}
	return node;
}

定义MBTree函数，递归建立二叉搜索树(输入0表示null，不为null的根结点还需要2个子树)，返回根结点的地址： 
BiTree MBTree()
{
	// 输入二叉树data		输入0表示NULL 
	BiTree root = NULL;
	DataType d;
	scanf("%d", &d);
	if(d != 0)
	{
		root = newNode(d);
		root->left = MBTree();
		root->right = MBTree();
	}
	return root;
}
/*----------------------------------到此为止，完成二叉搜索树定义-----------------------------------------*/

二叉树的先序遍历(使用递归的思想)： 
void PreOrder(BiTree root)
{
	if(root != NULL)
	{
		printf("%d ", root->data);
		PreOrder(root->left);
		PreOrder(root->right);
	}
}

     因为C语言库函数没有栈，因此需要自定义栈(在后序非递归遍历的时候使用) (尽量做到与C++库函数功能一样)： 
struct stack{
	BiTNode *elem[maxSize];
	int top;
};
// 栈初始化 
void initStack(Stack *S)
{
	S->top = -1;
}
// 判断栈空否，空栈时返回1，否则返回0 
int IsStackEmpty(Stack *S)
{
	if(S->top < 0)
		return 1;
	else
		return 0;
}
// 读栈顶元素，用x返回栈顶元素的值(不退栈)，若成功返回1 
BiTree getTop(Stack *S)
{
	if(IsStackEmpty(S))
		return NULL;
	else
		return S->elem[S->top];
}
// 进栈，成功返回1，否则返回0 
int Push(Stack *S, BiTNode *x)
{
	if(S->top >= maxSize)
		return 0;
	else
		S->elem[++S->top] = x;
	return 1;
}
// 出栈，栈非空时，出栈成功返回1，否则返回0 
int Pop(Stack *S, BiTNode **x)
{
	if(S->top < 0)
		return 0;
	else
		*x = S->elem[S->top--];
	return 1;
}
二叉树的中序非递归遍历(需要使用栈)：
 
void InOrder(BiTree root)
{
	Stack *S = (Stack *)malloc(sizeof(struct stack));	// 建立栈 
	initStack(S);			// 栈元素定义为 
	BiTNode *p = root;			// p是遍历指针，从根节点开始 
	do
	{
		while(p != NULL)		// 非空二叉树，沿左链进栈 
		{
			Push(S, p);
			p = p->left;
		}
		if(!IsStackEmpty(S))			// 栈不空时退栈 
		{
			Pop(S, &p);
			printf("%d ", p->data);
			p = p->right;		// 遍历指针进到右子女节点 
		}
	}
	while(p != NULL || !IsStackEmpty(S));
}

    因为C语言库函数没有队列，因此需要自定义队列(在层次遍历的时候使用) (尽量做到与C++库函数功能一样)： 
struct queue{
	BiTNode *elem[maxSize];
	int front, rear;	// 循环队列的队头、队尾指针 
};

// 队列初始化：创建一个空的队列Q并初始化 
void initQueue(Queue *Q)
{
	Q->front = 0;
	Q->rear = 0;
}

// 判断队列空否：当队列Q为空时函数返回1，否则返回0 
int IsQueueEmpty(Queue *Q)
{
	if(Q->front == Q->rear)
		return 1;
	else
		return 0;
}

// 进队列：当队列Q未满时，将元素成为队尾，成功返回1，否则返回0 
// 进队列：elem[rear]存入数据，rear再++ 
int enQueue(Queue *Q, BiTNode *x)
{
	if((Q->rear+1) % maxSize == Q->front)
		return 0;
	else
	{
		Q->elem[Q->rear] = x;
		Q->rear = (Q->rear+1) % maxSize;
		return 1;
	}
}

// 出队列：当队列Q非空时，将队头元素退出，成功返回1，否则返回0 
int deQueue(Queue *Q, BiTNode **x)
{
	if(IsQueueEmpty(Q))
		return 0;
	else
	{
		*x = Q->elem[Q->front];
		Q->front = (Q->front+1) % maxSize;
		return 1;
	}
}
二叉树的层次遍历(需要使用队列)： 
void LevelOrder(BiTree root)
{
	BiTNode *p;
	Queue Q;		// 建立一个队列 
	initQueue(&Q);		// 初始化队列 
	
	enQueue(&Q, root);		// 入栈队列 
	while(!IsQueueEmpty(&Q))
	{
		deQueue(&Q, &p);
		printf("%d ", p->data);
		if(p->left != NULL)
			enQueue(&Q, p->left);
		if(p->right != NULL)
			enQueue(&Q, p->right);
	}
}

二叉树的后序非递归遍历(需要使用栈)： 
void LastOrder(BiTree root)
{
	BiTree temp = NULL;
	Stack *S = (Stack *)malloc(sizeof(struct stack));	// 建立栈 
	initStack(S);
	while(root != NULL || !IsStackEmpty(S))
	{
		while(root != NULL)		// root和全部左子树 都压栈 
		{
			Push(S, root);
			root = root->left;
		}
		if(!IsStackEmpty(S))
			if(getTop(S)->right != NULL)		// 栈顶元素有右子树 
				root = getTop(S)->right;
			else
			{
				do								// 栈顶元素没有右子树 
				{
					Pop(S, &temp);
					printf("%d ", temp->data);
					root = getTop(S);			// root 可能为 null 
				}
				while(!IsStackEmpty(S) && root->right == temp);
				//	栈不空 并且 出栈元素是栈顶元素的右子树 
			}
		if(root && root->left == temp)			// 出栈元素是栈顶元素的左子树 
			root = root->right;
	}
}

下面给出完整代码：
建立二叉搜索树、递归遍历、非递归中序和后序遍历、自定义栈、自定义队列 
#include <stdio.h>
#include <stdlib.h>			//#include <malloc.h>
// 建立二叉树，搜索二叉树 

#define maxSize 100
typedef int DataType;
typedef struct node *BiTree;
typedef struct node BiTNode;
typedef struct stack Stack;
typedef struct queue Queue;

struct node
{
	DataType data;
	struct node *left, *right;
};

//-------------------------栈定义---------------------------- 
struct stack{
	BiTNode *elem[maxSize];
	int top;
};
// 栈初始化 
void initStack(Stack *S)
{
	S->top = -1;
}
// 判断栈空否，空栈时返回1，否则返回0 
int IsStackEmpty(Stack *S)
{
	if(S->top < 0)
		return 1;
	else
		return 0;
}
// 读栈顶元素，用x返回栈顶元素的值(不退栈)，若成功返回1 
BiTree getTop(Stack *S)
{
	if(IsStackEmpty(S))
		return NULL;
	else
		return S->elem[S->top];
}
// 进栈，成功返回1，否则返回0 
int Push(Stack *S, BiTNode *x)
{
	if(S->top >= maxSize)
		return 0;
	else
		S->elem[++S->top] = x;
	return 1;
}
// 出栈，栈非空时，出栈成功返回1，否则返回0 
int Pop(Stack *S, BiTNode **x)
{
	if(S->top < 0)
		return 0;
	else
		*x = S->elem[S->top--];
	return 1;
}
//-------------------------栈定义end---------------------------- 


//-------------------------队列定义----------------------------- 
struct queue{
	BiTNode *elem[maxSize];
	int front, rear;	// 循环队列的队头、队尾指针 
};

// 队列初始化：创建一个空的队列Q并初始化 
void initQueue(Queue *Q)
{
	Q->front = 0;
	Q->rear = 0;
}

// 判断队列空否：当队列Q为空时函数返回1，否则返回0 
int IsQueueEmpty(Queue *Q)
{
	if(Q->front == Q->rear)
		return 1;
	else
		return 0;
}

// 进队列：当队列Q未满时，将元素成为队尾，成功返回1，否则返回0 
// 进队列：elem[rear]存入数据，rear再++ 
int enQueue(Queue *Q, BiTNode *x)
{
	if((Q->rear+1) % maxSize == Q->front)
		return 0;
	else
	{
		Q->elem[Q->rear] = x;
		Q->rear = (Q->rear+1) % maxSize;
		return 1;
	}
}

// 出队列：当队列Q非空时，将队头元素退出，成功返回1，否则返回0 
int deQueue(Queue *Q, BiTNode **x)
{
	if(IsQueueEmpty(Q))
		return 0;
	else
	{
		*x = Q->elem[Q->front];
		Q->front = (Q->front+1) % maxSize;
		return 1;
	}
}

//-------------------------队列定义end--------------------------



BiTree newNode(DataType d)		// 开辟新结点 
{
	BiTree n = (BiTree)malloc(sizeof(struct node));
	n->data = d;
	n->left = n->right = NULL;
	return n;
}

BiTree Insert(BiTree node, DataType d)
{
	if(!node)
		node = newNode(d);		// 结点的value 
	else
	{
		if(d >= node->data)
			node->right = Insert(node->right, d);
		else
			node->left = Insert(node->left, d);
	}
	return node;
}
BiTree MBTree()
{
	// 输入二叉树data		输入0表示NULL 
	BiTree root = NULL;
	DataType d;
	scanf("%d", &d);
	if(d != 0)
	{
		root = newNode(d);
		root->left = MBTree();
		root->right = MBTree();
	}
	return root;
}

// 先序递归遍历 
void PreOrder(BiTree root)
{
	if(root != NULL)
	{
		printf("%d ", root->data);
		PreOrder(root->left);
		PreOrder(root->right);
	}
}

// 中序非递归遍历 
void InOrder(BiTree root)
{
	Stack *S = (Stack *)malloc(sizeof(struct stack));	// 建立栈 
	initStack(S);			// 栈元素定义为 
	BiTNode *p = root;			// p是遍历指针，从根节点开始 
	do
	{
		while(p != NULL)		// 非空二叉树，沿左链进栈 
		{
			Push(S, p);
			p = p->left;
		}
		if(!IsStackEmpty(S))			// 栈不空时退栈 
		{
			Pop(S, &p);
			printf("%d ", p->data);
			p = p->right;		// 遍历指针进到右子女节点 
		}
	}
	while(p != NULL || !IsStackEmpty(S));
}

// 层次遍历 
void LevelOrder(BiTree root)
{
	BiTNode *p;
	Queue Q;		// 建立一个队列 
	initQueue(&Q);		// 初始化队列 
	
	enQueue(&Q, root);		// 入栈队列 
	while(!IsQueueEmpty(&Q))
	{
		deQueue(&Q, &p);
		printf("%d ", p->data);
		if(p->left != NULL)
			enQueue(&Q, p->left);
		if(p->right != NULL)
			enQueue(&Q, p->right);
	}
}

// 后序遍历 
void LastOrder(BiTree root)
{
	BiTree temp = NULL;
	Stack *S = (Stack *)malloc(sizeof(struct stack));	// 建立栈 
	initStack(S);
	while(root != NULL || !IsStackEmpty(S))
	{
		while(root != NULL)		// root和全部左子树 都压栈 
		{
			Push(S, root);
			root = root->left;
		}
		if(!IsStackEmpty(S))
			if(getTop(S)->right != NULL)		// 栈顶元素有右子树 
				root = getTop(S)->right;
			else
			{
				do				// 栈顶元素没有右子树 
				{
					Pop(S, &temp);
					printf("%d ", temp->data);
					root = getTop(S);			// root 可能为 null 
				}
				while(!IsStackEmpty(S) && root->right == temp);
				//	栈不空 并且 出栈元素是栈顶元素的右子树 
			}
		if(root && root->left == temp)			// 出栈元素是栈顶元素的左子树 
			root = root->right;
	}
}

int main()
{
	BiTree root;	
	root = MBTree();	// 建立二叉搜索树，输入0表示NULL 
	PreOrder(root);		// 先序递归遍历 
	printf("\n");
	
	InOrder(root);		// 中序非递归遍历:栈 
	printf("\n");
	
	LevelOrder(root);		// 层次遍历:堆 
	printf("\n");
	
	LastOrder(root);		// 后序非递归遍历:栈 
	printf("\n");
	
	return 0;
}




运行结果图：




Hozy_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉搜索树实例练习
09-05
二叉搜索树（Binary Search Tree，BST），是一种特殊的二叉树结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉搜索树中，对于任意节点： 1. 节点的左...
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
重现二叉搜索树递归构建的过程
No detail can be too detailed
07-16 1163
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 简单而言就是 左边的小于中间 中间的小于右边 首先建立几个数据变量 #define TYPE i
二叉搜索树建立、插入、删除、前继节点、后继节点之c++实现
XIAXIA__的专栏
11-08 5628
一、前言 一直以来，都对树有关的东西望而却步。以前每次说要看一看，都因为惰性，时间就那么荒废掉了。今天下个决心，决定好好的数据结构中的东西看一下。不知道看这篇文章的你，是不是和我有同样的感受，空有一颗努力的心，却迟迟没有付出行动。如果是的话，如果也想好好的把树的知识巩固一下的话，就让我们一起好好儿地把知识点过一遍吧。本文争取让看完的每一个没有基础的同学，都能有所收获。在正文开始前，先给自己加个油
二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
热门推荐
weixin_54186646的博客
04-25 8万+
图解二叉排序树（二叉查找树、二叉搜索树）的插入操作、查找操作、删除操作以及完整的代码实现
【Java 数据结构】实现一个二叉搜索树
最新发布
程序猿教你打篮球的博客
01-09 6909
本期主要讲解： 1、认识二叉搜索树 2、实现一个二叉搜索树 2.1 成员变量 2.2 insert 方法 2.3 search 方法 2.4 remove 方法(重点) 3、二叉搜索树总结
二叉搜索树详解
拂晓123的博客
06-17 5705
写在前面        本文主要分为三个部分。        第一部分介绍了二叉搜索树的基本性质。        第二部分全面详细地讲述了二叉搜索树的各种基本操作...
java二叉搜索树详解
m0_57180439的博客
02-21 2078
文章目录一、概念二、相关操作1.查找2.插入2.删除实现 提示：以下是本篇文章正文内容，下面案例可供参考 一、概念 二叉搜索树又称二叉排序树 它或者是一棵空树，或者是具有以下性质的二叉树: 1.若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 2.若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 3.它的左右子树也分别为二叉搜索树 （图片来自比特就业课） 二、相关操作 1.查找 （图片来自比特就业课） 代码如下（示例）： 2.插入 代码如下（示例）： 2.删除 实现 ....
二叉搜索树(二叉排序树)
爱敲代码的三毛的博客
09-09 4万+
一.概念 二叉搜索树又称二叉排序树，具有以下性质： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 注意：二叉搜索树中序遍历的结果是有序的 二、基本操作 1.查找元素 思路：二叉搜索树的左子树永远是比根节点小的，而它的右子树则都是比根节点大的值。当前节点比要找的大就往左走，当前元素比要找的小就往右走 public Node search(int key) { if(root ==
判断二叉树是否为二叉搜索树
明朗晨光的专栏
07-01 5731
利用二叉树递归套路判断是否为二叉搜索树
二叉搜索树（BinarySearchTree）
潜心钻研技术
03-05 1418
二叉搜索树（BinarySearchTree） 文章目录二叉搜索树（BinarySearchTree）二叉搜索树的概念如何定义 二叉搜索树的节点 && 二叉搜索树查找插入删除二叉搜索树的缺点二叉搜索树的应用 二叉搜索树的概念 搜索二叉树满足一下条件： 是一棵二叉树 这可树上的任意一个节点满足：若他的右子树不为空，则右子树上的所有节点的值大于该节点的值 这可树上的任意一个节点满足：若他的左子树不为空，则左子树上的所有节点的值小于该节点的值 它的的左子树和右子树也是二叉搜索树 例如下图就是一
java实现 二叉搜索树功能
08-27
Java 实现二叉搜索树功能 二叉搜索树是一种特殊的二叉树，它的每个节点都含有一个Comparable的键值，且所有的键值都是唯一的，节点的键值也可以是基本类型，如int、long等，也可以是自定义的对象类型，只要实现了...
C#二叉搜索树插入算法实例分析
01-21
本文实例讲述了C#二叉搜索树插入算法。分享给大家供大家参考。具体实现方法如下： public class BinaryTreeNode { public BinaryTreeNode Left { get; set; } public BinaryTreeNode Right { get; set; } public...
二叉搜索树_二叉搜索树_源码
10-04
在给定的“二叉搜索树_二叉搜索树_源码”压缩包中，包含了一个名为“二叉搜索树.c”的源代码文件和一个编译后的可执行文件“二叉搜索树.exe”。源代码文件很可能是用C语言编写的，用于演示如何实现二叉搜索树的基本...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
Java二叉搜索树基础原理与实现方法详解
08-19
Java二叉搜索树基础原理与实现方法详解 本文详细介绍了Java二叉搜索树的基础原理与实现方法，涵盖了二叉树的定义、特点、二叉搜索树的定义、性质、思想、编程实现等方面的知识点。 一、树的定义 树是n（n>=0）个...
树-98. 验证二叉搜索树-PYTHON
01-20
递归 # Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution(object): def isValidBST(self, root): ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值