c语言搜索二叉树各种功能代码

于 2023-12-13 00:15:00 发布
阅读量590 收藏 8
点赞数 20
分类专栏： c语言数据结构 文章标签： c语言 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bodyzsm/article/details/134948108
版权

目录

介绍：

代码：

写代码前提：

 向二叉树中插入数据代码：

 获取二叉树的高度代码：

 获取二叉树中最大的值代码：

获取二叉树中最小的值代码： 

 删除二叉树中的节点代码：

 判断二叉树是否为空代码：

 二叉树前序遍历代码：

 二叉树中序遍历代码：

 二叉树后序遍历代码：

全部代码：

 结尾：

介绍：

本篇文章仅仅介绍c语言搜索二叉树各种功能代码 不提供讲解 各位见谅

代码：

写代码前提：

写代码之前先看一看 完成c语言搜索二叉树各种功能 所需要的头文件和结构体

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	int data;
	struct node* left;
	struct node* right;
}node;

 向二叉树中插入数据代码：

node* insert_data(node* tree_root, int data)
{
	node* newnode = (node*)malloc(sizeof(node));
	node* m = tree_root;

	newnode->data = data;
	newnode->left = NULL;
	newnode->right = NULL;
	if (tree_root == NULL)
	{
		tree_root = newnode;
		return tree_root;
	}
	while (m != NULL)
	{
		if (data < m->data)
		{
			if (m->left == NULL)
			{
				m->left = newnode;
				break;
			}
			else
			{
				m = m->left;
			}
		}
		else
		{
			if (m->right == NULL)
			{
				m->right = newnode;
				break;
			}
			else
			{
				m = m->right;
			}
		}
	}
	return tree_root;
}

 获取二叉树的高度代码：

int tree_high(node* tree_root)
{
	if (tree_root == NULL)
	{
		return 0;
	}
	else
	{
		int left_high = tree_high(tree_root->left);
		int right_high = tree_high(tree_root->right);
		int high = left_high;

		if (right_high > high)
		{
			high = right_high;
		}

		return high + 1;
	}
}

 获取二叉树中最大的值代码：

int tree_maximum(node* tree_root)
{
	if (tree_root == NULL)
	{
		return -1;
	}
	else
	{
		int left_max = tree_maximum(tree_root->left);
		int right_max = tree_maximum(tree_root->right);
		int maximum = tree_root->data;

		if (maximum < left_max)
		{
			maximum = left_max;
		}
		if (maximum < right_max)
		{
			maximum = right_max;
		}
		return maximum;
	}
}

获取二叉树中最小的值代码： 

int tree_minimum(node* tree_root)
{
	if (tree_root == NULL)
	{
		return 10000;
	}
	else
	{
		int left_min = tree_minimum(tree_root->left);
		int right_min = tree_minimum(tree_root->right);
		int minimum = tree_root->data;

		if (minimum > left_min)
		{
			minimum = left_min;
		}
		if (minimum > right_min)
		{
			minimum = right_min;
		}
		return minimum;
	}
}

 删除二叉树中的节点代码：

node* delete_node(node* tree_root, int data)
{
	if (tree_root == NULL)
	{
		printf("The tree is NULL\n");
		return NULL;
	}
	node* p = tree_root;
	node* fp = NULL;

	while (1)
	{
		fp = p;
		if (data > p->data)
		{
			if (p->right == NULL)
			{
				printf("The tree haven't the number\n");
				return tree_root;
			}
			p = p->right;
		}
		else if (data < p->data)
		{
			if (p->left == NULL)
			{
				printf("The tree haven't the number\n");
				return tree_root;
			}
			p = p->left;
		}
		if (p->data == data)
		{
			break;
		}
	}
	if (p->left != NULL && p->right != NULL)
	{
		node* q = p;

		fp = p;
		p = p->right;
		while (p->left != NULL)
		{
			fp = p;
			p = p->left;
		}
		q->data = p->data;
		if (fp->right == p)
		{
			fp->right = p->right;
			free(p);
			p = NULL;
		}
		else if (fp->left == p)
		{
			fp->left = p->right;
			free(p);
			p = NULL;
		}
		return tree_root;
	}
	else if (p->left == NULL && p->right == NULL)
	{
		if (p == tree_root)
		{
			free(p);
			p = NULL;
			return NULL;
		}
		else if (fp->left == p)
		{
			fp->left = NULL;
			free(p);
			p = NULL;
		}
		else if (fp->right == p)
		{
			fp->right = NULL;
			free(p);
			p = NULL;
		}
		return tree_root;
	}
	else if (p->left != NULL && p->right == NULL)
	{
		if (p == tree_root)
		{
			tree_root = p->left;
			p->left = NULL;
			free(p);
			return tree_root;
		}
		else if (fp->left == p)
		{
			fp->left = p->left;
			p->left = NULL;
			free(p);
			p = NULL;
		}
		else if (fp->right == p)
		{
			fp->right = p->left;
			p->left = NULL;
			free(p);
			p = NULL;
		}
		return tree_root;
	}
	else if (p->left == NULL && p->right != NULL)
	{
		if (p == tree_root)
		{
			tree_root = p->right;
			p->right = NULL;
			free(p);
			return tree_root;
		}
		if (fp->left == p)
		{
			fp->left = p->right;
			p->right = NULL;
			free(p);
			p = NULL;
		}
		if (fp->right == p)
		{
			fp->right = p->right;
			p->right = NULL;
			free(p);
			p = NULL;
		}
		return tree_root;
	}
}

 判断二叉树是否为空代码：

int empty(node* tree_root)
{
	if (tree_root == NULL)
	{
		printf("The tree is NULL\n");
		return 0;
	}
	else
	{
		return 1;
	}
}

 二叉树前序遍历代码：

void preorder(node* tree_root)
{
	if (tree_root != NULL)
	{
		printf("%d ", tree_root->data);
		preorder(tree_root->left);
		preorder(tree_root->right);
	}
}

 二叉树中序遍历代码：

void inorder(node* tree_root)
{
	if (tree_root != NULL)
	{
		inorder(tree_root->left);
		printf("%d ", tree_root->data);
		inorder(tree_root->right);
	}
}

 二叉树后序遍历代码：

void taorder(node* tree_root)
{
	if (tree_root != NULL)
	{
		taorder(tree_root->left);
		taorder(tree_root->right);
		printf("%d ", tree_root->data);
	}
}

全部代码：

这个全部代码包括小编自己训练的部分 大家应该有用：

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
	int data;
	struct node* left;
	struct node* right;
}node;

node* insert_data(node* tree_root, int data);
void preorder(node* tree_root);
void inorder(node* tree_root);
void taorder(node* tree_root);
int tree_high(node* tree_root);
int tree_maximum(node* tree_root);
int tree_minimum(node* tree_root);
node* delete_node(node* tree_root, int data);
int empty(node* tree_root);

int main(void)
{
	int a[16] = { 7,6,4,3,16,15,13,5,25,30,24,32,23 ,38,36,41 };
	int tree_high1;
	int tree_maximum1;
	int tree_minimum1;
	node* tree_root = NULL;

	for (int i = 0; i < 16; i++)
	{
		tree_root = insert_data(tree_root, a[i]);
	}
	if (empty(tree_root))
	{
		printf("The tree's preorder is : ");
		preorder(tree_root);
		putchar('\n');
	}
	if (empty(tree_root))
	{
		printf("The tree's inorder is : ");
		inorder(tree_root);
		putchar('\n');
	}
	if (empty(tree_root))
	{
		printf("The tree's taorder is : ");
		taorder(tree_root);
		putchar('\n');
	}
	if (empty(tree_root))
	{
		tree_high1 = tree_high(tree_root);
		printf("The tree's high = %d", tree_high1);
		putchar('\n');
	}
	if (empty(tree_root))
	{
		tree_maximum1 = tree_maximum(tree_root);
		printf("The tree's maximum = %d", tree_maximum1);
		putchar('\n');
	}
	if (empty(tree_root))
	{
		tree_minimum1 = tree_minimum(tree_root);
		printf("The tree's minimum = %d", tree_minimum1);
		putchar('\n');
	}
	for (int i = 0; i < 16; i++)
	{
		tree_root = delete_node(tree_root, a[i]);
	}
	if (empty(tree_root))
	{
		printf("The  delete' tree is : ");
		inorder(tree_root);
		putchar('\n');
	}

	return 0;
}


node* insert_data(node* tree_root, int data)
{
	node* newnode = (node*)malloc(sizeof(node));
	node* m = tree_root;

	newnode->data = data;
	newnode->left = NULL;
	newnode->right = NULL;
	if (tree_root == NULL)
	{
		tree_root = newnode;
		return tree_root;
	}
	while (m != NULL)
	{
		if (data < m->data)
		{
			if (m->left == NULL)
			{
				m->left = newnode;
				break;
			}
			else
			{
				m = m->left;
			}
		}
		else
		{
			if (m->right == NULL)
			{
				m->right = newnode;
				break;
			}
			else
			{
				m = m->right;
			}
		}
	}
	return tree_root;
}

void preorder(node* tree_root)
{
	if (tree_root != NULL)
	{
		printf("%d ", tree_root->data);
		preorder(tree_root->left);
		preorder(tree_root->right);
	}
}

void inorder(node* tree_root)
{
	if (tree_root != NULL)
	{
		inorder(tree_root->left);
		printf("%d ", tree_root->data);
		inorder(tree_root->right);
	}
}

void taorder(node* tree_root)
{
	if (tree_root != NULL)
	{
		taorder(tree_root->left);
		taorder(tree_root->right);
		printf("%d ", tree_root->data);
	}
}

int tree_high(node* tree_root)
{
	if (tree_root == NULL)
	{
		return 0;
	}
	else
	{
		int left_high = tree_high(tree_root->left);
		int right_high = tree_high(tree_root->right);
		int high = left_high;

		if (right_high > high)
		{
			high = right_high;
		}

		return high + 1;
	}
}

int tree_maximum(node* tree_root)
{
	if (tree_root == NULL)
	{
		return -1;
	}
	else
	{
		int left_max = tree_maximum(tree_root->left);
		int right_max = tree_maximum(tree_root->right);
		int maximum = tree_root->data;

		if (maximum < left_max)
		{
			maximum = left_max;
		}
		if (maximum < right_max)
		{
			maximum = right_max;
		}
		return maximum;
	}
}

int tree_minimum(node* tree_root)
{
	if (tree_root == NULL)
	{
		return 10000;
	}
	else
	{
		int left_min = tree_minimum(tree_root->left);
		int right_min = tree_minimum(tree_root->right);
		int minimum = tree_root->data;

		if (minimum > left_min)
		{
			minimum = left_min;
		}
		if (minimum > right_min)
		{
			minimum = right_min;
		}
		return minimum;
	}
}

node* delete_node(node* tree_root, int data)
{
	if (tree_root == NULL)
	{
		printf("The tree is NULL\n");
		return NULL;
	}
	node* p = tree_root;
	node* fp = NULL;

	while (1)
	{
		fp = p;
		if (data > p->data)
		{
			if (p->right == NULL)
			{
				printf("The tree haven't the number\n");
				return tree_root;
			}
			p = p->right;
		}
		else if (data < p->data)
		{
			if (p->left == NULL)
			{
				printf("The tree haven't the number\n");
				return tree_root;
			}
			p = p->left;
		}
		if (p->data == data)
		{
			break;
		}
	}
	if (p->left != NULL && p->right != NULL)
	{
		node* q = p;

		fp = p;
		p = p->right;
		while (p->left != NULL)
		{
			fp = p;
			p = p->left;
		}
		q->data = p->data;
		if (fp->right == p)
		{
			fp->right = p->right;
			free(p);
			p = NULL;
		}
		else if (fp->left == p)
		{
			fp->left = p->right;
			free(p);
			p = NULL;
		}
		return tree_root;
	}
	else if (p->left == NULL && p->right == NULL)
	{
		if (p == tree_root)
		{
			free(p);
			p = NULL;
			return NULL;
		}
		else if (fp->left == p)
		{
			fp->left = NULL;
			free(p);
			p = NULL;
		}
		else if (fp->right == p)
		{
			fp->right = NULL;
			free(p);
			p = NULL;
		}
		return tree_root;
	}
	else if (p->left != NULL && p->right == NULL)
	{
		if (p == tree_root)
		{
			tree_root = p->left;
			p->left = NULL;
			free(p);
			return tree_root;
		}
		else if (fp->left == p)
		{
			fp->left = p->left;
			p->left = NULL;
			free(p);
			p = NULL;
		}
		else if (fp->right == p)
		{
			fp->right = p->left;
			p->left = NULL;
			free(p);
			p = NULL;
		}
		return tree_root;
	}
	else if (p->left == NULL && p->right != NULL)
	{
		if (p == tree_root)
		{
			tree_root = p->right;
			p->right = NULL;
			free(p);
			return tree_root;
		}
		if (fp->left == p)
		{
			fp->left = p->right;
			p->right = NULL;
			free(p);
			p = NULL;
		}
		if (fp->right == p)
		{
			fp->right = p->right;
			p->right = NULL;
			free(p);
			p = NULL;
		}
		return tree_root;
	}
}

int empty(node* tree_root)
{
	if (tree_root == NULL)
	{
		printf("The tree is NULL\n");
		return 0;
	}
	else
	{
		return 1;
	}
}

 结尾：

还是那句话  大家不要直接粘贴复制 要自己动手敲一下 动动脑子思考一下

大家加油吧

散会

！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

赵世满
关注
专栏目录
二叉搜索树详解——附加C语言代码实现
likunkun__的博客
08-31 2274
二叉搜索树： 对于树中的每个节点X，它的左子树中所有项的值都小于X，右子树所有值都大于X，并且没有重复。 一、构造树： 树可以由一个个的节点构成，所以先定义节点结构体，和数据类型变量重命名 typedef int BSTDataType; typedef struct BSTreeNode { struct BSTreeNode* _left; struct BSTreeNode*...
搜索c语言代码,二叉搜索树BST(C语言实现可用)(示例代码)
weixin_30224231的博客
05-21 385
1:概述搜索树是一种可以进行插入，搜索，删除等操作的数据结构，可以用作字典或优先级队列。二叉搜索树是最简单的搜索树。其左子树的键值<=根节点的键值，右子树的键值>=根节点的键值。如果共有n个元素,那么每次操作需要的O(log n)的时间.常用知识点满二叉树 :一棵深度为k，且有2^k-1个节点的二叉树，称为满二叉树。这种树的特点是每一层上的节点数都是最大节点数。完全二叉树 : 而在一...
二叉搜索树C语言代码实现
weixin_61819021的博客
05-20 1686
有些题里除了这个概念，不知道的话就蒙圈了。 先序遍历： root——>left——>right 中序遍历： left—— root ——>right 先弄一个只有四个节点的小型二叉树，实际上这种小型二叉树应用不大。 二叉树的真正应用是二叉搜索树，处理海量的数据。 代码很简单，两种遍历的代码也差不多 #include<stdio.h> #include<stdlib.h> typedef struct node{ int data; struct n
C语言数据结构代码——二叉搜索树
qq_41862220的博客
04-28 301
Head.H #define ARRSIZE 6 typedef struct _tnode { int ele; struct _tnode *ltree; struct _tnode *rtree; }TNode, *tnode; void InsertTree(tnode T, int num); tnode InitSearchTree(int *a, int len); ...
二叉搜索树 c语言,二叉搜索树（C语言实现）
weixin_39823459的博客
05-23 356
数据结构typedef struct TreeNode {int data;//数据struct TreeNode* left;//左孩子struct TreeNode* right;//右孩子}BST, *BinTree;函数声明void Insert(BinTree& BST, int x);//插入元素void Delete(BinTree& BST, int x);//删除...
C语言翻转二叉树.zip
10-28
在IT领域，二叉树是一种基础...二叉树翻转在很多实际问题中都有应用，比如在图像处理中的水平镜像、某些搜索算法的优化、数据结构的转换等。理解并掌握这种操作对于提升C语言编程技能和深入理解数据结构是至关重要的。
C语言平衡二叉树.zip
10-27
为了完整地实现一个C语言平衡二叉树，还需要编写一个驱动程序来测试这些功能。在`isBalancedTree-master`这个项目中，可能包含了实现这些功能的源代码文件和测试用例。读者可以通过阅读这些代码来加深对平衡二叉树的...
C语言实现二叉树的基本操作源码.zip
最新发布
10-30
5. **搜索节点**：在二叉树中搜索特定值的节点，通过比较节点值与目标值进行递归搜索。 ```c TreeNode* searchNode(TreeNode* root, int val) { if (root == NULL || root->val == val) return root; if (val ...
c语言版本二叉树基本操作示例(先序 递归 非递归)
09-04
在本文中，我们将探讨如何在C语言中实现二叉树的基本操作...以上就是C语言实现的二叉树基本操作，包括创建、遍历等关键功能。通过递归和非递归方法，我们可以灵活地处理二叉树的各种问题，这在实际编程中是非常有用的。
C语言实现二叉树的创建、插入、删除、遍历等操作
12-14
应当包含了实现这些功能的C语言源代码，可能包括了函数定义如`createNode()`, `insertNode()`, `deleteNode()`, `preorderTraversal()`, `inorderTraversal()`, `postorderTraversal()`等，以及对二叉树度数统计和...
c语言实现二叉搜索树
03-23
1.实现二叉搜索树的基本操作 2.包括建立，查找，删除，显示 3.得到最长路径和最短路径，并能分别计算长度
二叉排序树的操作（C语言实现）
01-08
本程序实现了二叉排序树的建立，插入和删除结点等操作，经调试无误
二叉排序树c语言,数据结构：二叉查找树(C语言实现)(示例代码)
weixin_34345599的博客
05-19 571
?写在前面关于二叉树的基础知识，请看我的一篇博客:二叉树的链式存储说明：二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：1.若其左子树不空，则左子树上所有结点的值均小于它的根结点的值；2.若其右子树不空，则右子树上所有结点的值均大于它的根结点的值;3.其左、右子树也分别为二叉排序树?二叉查找树的建立(插入)：说明：二叉树的创建是二叉树反复插入节点所构造出来的！若二叉树为空树，则插入元素作为树...
[C语言]二叉搜索树
CRAJA的blog
04-09 255
目录结构体二叉搜索树的插入(创建)查找值查找最小值和最大值删除单个节点遍历全部代码效果图 结构体 这个和普通的二叉树一样的 typedef struct BiTNode { DataType data; //数值 struct BiTNode* lchild; //左孩子 struct BiTNode* rchild; //右孩子 int flag; //非递归遍历时可能会使用到 } BiTNode,*BiTree; //搜索树结构体 二叉搜索树的插入(创建) 这个相当于创建了
二叉搜索树（C语言实现）
weixin_46272577的博客
04-30 608
#include <iostream> #include <queue> #include <cstdio> #include <cstdlib> using namespace std; typedef struct TreeNode { int data;//数据 struct TreeNode* left;//左孩子 struct TreeNode* right;//右孩子 }BST, *BinTree; void Insert(Bin.
C语言实现二叉搜索树
hou19975418的博客
01-24 287
二叉搜索树的定义如图所示：一棵树，左子树上所有的结点值都比根节点小，右子树上所有的的结点值都比根节点大，同时结点不重复。
二叉搜索树 C语言实现
WTF
12-01 4202
1、二叉搜索树基本概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是一棵具有如下特性的非空二叉树： （1）若它的左子树非空，则左子树上所有结点的关键字均小于根结点的关键字； （2）若它的右子树非空，则右子树上所有结点的关键字均大于（允许的话，也可大于等于）根结点的关键字； （3）左右子树本身又各是一个二叉搜索树。 根据二叉搜索树的特点知：对二叉搜索树进行中序遍历得到的结点序列必然是一个有序序列。
树
黑色吊椅的博客
10-26 556
树的介绍 1. 树的定义 树是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。 把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： (01) 每个节点有零个或多个子节点； (02) 没有父节点的节点称为根节点； (03) 每一个非根节点有且只有一个父节点； (04) 除了根节点外，每个子节点可以分为多个不相交的子树...
数据结构 --- c语言二叉搜索树(有序的树)
weixin_60569662的博客
02-27 2716
二叉搜索树基础 左边孩子节点的值 < 父节点的值，右边孩子节点的值 > 父节点的值 每个二叉搜索树的子树也是一棵二叉搜索树 10 充当根节点 18 > 根节点，放在根节点右边；3 < 根节点，放在根节点左边；8 首先与根节点相比较，8 < 根节点，所以应该放在根节点的左边；然后 8 与 3 比较，3 < 8，8 应该放在 3 的右边，持续构建即可 二叉搜索树的特性：中序遍历是一个有序序列，从小到大排序，2-3-4-7-.
掌握C语言二叉树实现：代码与数据结构详解
资源摘要信息:"数据结构第五章-树与二叉树二叉树的C语言实现代码" 该资源是一份关于数据结构中树与二叉树主题的C语言实现教程，涵盖了二叉树的理论知识与实际编码实践。资源主要包含两大部分内容：一是二叉树相关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

赵世满

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值