二叉排序树 -- C语言

最新推荐文章于 2022-03-02 17:42:42 发布
最新推荐文章于 2022-03-02 17:42:42 发布
阅读量513 收藏
点赞数
分类专栏： 数据结构 面试 工作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leoufung/article/details/104466529
版权
工作 同时被 3 个专栏收录
105 篇文章 2 订阅
订阅专栏
面试
83 篇文章 2 订阅
订阅专栏
数据结构
30 篇文章 0 订阅
订阅专栏

数据结构

二 叉 排序 树（ Binary Sort Tree） 又称 二 叉 查找 树（ Binary Search Tree）。 其 定义 为： 二 叉 排序 树 或者是 空 树， 或者是 满足 如下 性 质的 二 叉 树。

（1） 若 它的 左 子 树 非 空， 则 左 子 树上 所有 节点 的 值 均 小于 根 节点 的 值。

（2） 若 它的 右 子 树 非 空， 则 右 子 树上 所有 节点 的 值 均 大于 根 节点 的 值。

（3） 左、 右 子 树 本身 又 各 是一 棵 二 叉 排序 树。 上述 性质 简称 二 叉 排序 树 性质（ BST 性质）， 故 二 叉 排序 树 实际上 是 满足 BST 性 质的 二 叉 树。

下图 就是 一个 简单 的 二 叉 排序 树。

首先 我们 需要 定义 节点 类 以及 二 叉 排序 树 类。 对于 节点 类 来说， 显然 每个 节点 有 向下 的 两个 指针， 而且 每个 节点 都 只有 一个 父 节点。 对于 二 叉 排序 树 类 来说， 只需 要 有数 的 根 节点， 就可以 进行 操作 了。

代码实现

#include <stdio.h>
#include <stdlib.h>
#include "tree.h"
#include "stack.h"


st_trNode * createTreeNode(int data){
	st_trNode * p = NULL;

	p = (st_trNode * ) malloc (sizeof(st_trNode));
	if(NULL ==  p){
		printf("createTreeNode alloc failed \n");
		return NULL;
	}

	p->data = data;
	p->tag = 0;
	p->left = NULL;
	p->right = NULL;
	p->parent = NULL;

	return p;
}


int createTree(st_tree ** ptree){

	st_tree * tree = NULL;

	tree = (st_tree * ) malloc (sizeof(st_tree));
	if(NULL ==  tree){
		printf("createTree alloc failed \n");
		return ALLOC_ERR;
	}

	tree->root = NULL;

	*ptree = tree;

	return SUCCESS;
}

int insertBSTNode(st_trNode ** proot, st_trNode * node){
	if(NULL == proot || NULL == node){
		printf("insertBSTNode param error\n");
		return PARAM_ERR;
	}

	st_trNode * root = *proot;	
	st_trNode * left = NULL, * right = NULL, * p = NULL;;

	/* BST的首个节点 */
	if(NULL == root){
		root = node;
#ifdef DEBUG		
		printf("1.1  root = %d\n", root->data);		
#endif
		goto out;
	}

	/*递归结束条件：叶子节点*/
	if(NULL == root->left && NULL == root->right){
#ifdef DEBUG
		printf("1.6\n");
#endif
		if(node->data < root->data)	{
			root->left = node;
			node->parent = root;
#ifdef DEBUG		
			printf("1.2  left = %d, parent = %d \n", root->left->data, node->parent->data);	
#endif
		} else {
			root->right = node;
			node->parent = root;
#ifdef DEBUG	
			printf("1.3  right = %d, parent = %d \n", root->right->data, node->parent->data);	
#endif
		}
		goto out;
	}
	
	left= root->left;
	right = root->right;

#ifdef DEBUG
	printf("1.7\n");
#endif

	/*向左子树插入*/
	if(node->data < root->data){
		if(NULL == left){
#ifdef DEBUG
			printf("1.4.1  root = %d \n", root->data);	
#endif
			root->left = node;
			node->parent = root;
		} else{
#ifdef DEBUG			
			printf("1.4.2  root = %d, left = %d \n", root->data, left->data);	
#endif
			insertBSTNode(&left, node);			
			/*左子树根可能发生变化*/
			root->left = left;
			left->parent = root;
		}
	} else { /*向右子树插入*/
		if(NULL == right){
#ifdef DEBUG			
			printf("1.5.1  root = %d \n", root->data);
#endif
			root->right = node;
			node->parent = root;
		} else {
#ifdef DEBUG	
			printf("1.5.2  root = %d, right = %d \n", root->data, right->data);	
#endif
			insertBSTNode(&right, node);
			/*右子树根可能发生变化*/
			root->right = right;
			right->parent = root;
		}		
	}
	
out:
	* proot = root;
	return SUCCESS;
	
}

int TraverseTreePreOrder(st_trNode * root){

	/*递归结束条件*/
	if(NULL == root){
		return SUCCESS;
	}

	printf(" %d ", root->data);

	/*左子树*/
	if(NULL != root->left)
		TraverseTreePreOrder(root->left);

	/*右子树*/	
	if(NULL != root->right)
		TraverseTreePreOrder(root->right);

	return SUCCESS;
}


/*
 * 对于 BST 来说，中序打印出来的是升序的
 */
int TraverseTreeInOrder(st_trNode * root){

	/*递归结束条件*/
	if(NULL == root){
		return SUCCESS;
	}

	/*左子树*/
	if(NULL != root->left)
		TraverseTreeInOrder(root->left);

	printf(" %d ", root->data);

	/*右子树*/	
	if(NULL != root->right)
		TraverseTreeInOrder(root->right);

	return SUCCESS;
}

/*
 * 对于 BST 来说，中序打印出来的是升序的
 */
int TraverseTreePostOrder(st_trNode * root){

	/*递归结束条件*/
	if(NULL == root){
		return SUCCESS;
	}

	/*左子树*/
	if(NULL != root->left)
		TraverseTreePostOrder(root->left);

	/*右子树*/	
	if(NULL != root->right)
		TraverseTreePostOrder(root->right);

	printf(" %d ", root->data);

	return SUCCESS;
}



int dumpTree(st_tree * tree){

	/*递归结束条件*/
	if(NULL == tree){
		return SUCCESS;
	}
	
#if 1
	printf("========= Dump Tree PreOder: %p ===========\n\t", tree);
	TraverseTreePreOrder(tree->root);
	printf("\n===================================\n");


	printf("========= Dump Tree PreOder UnRec: %p ===========\n\t", tree);
	TraverseTreePreOrderUnrec(tree->root);
	printf("\n===================================\n");

#endif

#if 0
	printf("========= Dump Tree InOder: %p ===========\n\t", tree);
	TraverseTreeInOrder(tree->root);
	printf("\n===================================\n");

	printf("========= Dump Tree InOderUnrec: %p ===========\n\t", tree);
	TraverseTreeInOrderUnrec(tree->root);
	printf("\n===================================\n");	
#endif

#if 0
	printf("========= Dump Tree PostOrder: %p ===========\n\t", tree);
	TraverseTreePostOrder(tree->root);
	printf("\n===================================\n");

	printf("========= Dump Tree PostOrder unRec: %p ===========\n\t", tree);
	TraverseTreePostOrderUnrec(tree->root);
	printf("\n===================================\n");	
#endif


	return SUCCESS;
}

st_trNode * SearchBSTreeNode(st_trNode * root, int data){

	if(NULL == root){
		return NULL;
	}

	st_trNode * node = NULL;
	st_trNode * left = root->left, * right = root->right;
	
	if(data == root->data){
		return root;
	}

	if(NULL == left && NULL == right){
		return NULL;
	}

	if(data < root->data){
		if(NULL == left){
			return NULL;
		} else {
			node = SearchBSTreeNode(root->left, data);
		}
	} else {
		if(NULL == right){
			return NULL;
		} else {
			node = SearchBSTreeNode(root->right, data);
		}		
	}

	return node;

}


st_trNode * getMostLeftNode(st_trNode * root){
	if(NULL == root){
		return root;
	}

	st_trNode * p = NULL;

	if(NULL == root->left){
		return root;
	}

	p = root->left;
	while(NULL != p->left){
		p = p->left;
	}

	return p;
}

int removeBSTreeNode(st_trNode ** proot, int data){
	if(NULL == proot){
		printf("removeBSTreeNode param error\n");
		return PARAM_ERR;
	}

	st_trNode * root = *proot;
	st_trNode * node = NULL;
	st_trNode * left = NULL, * right = NULL, * parent = NULL;
	st_trNode * mostsubLeft = NULL; /*右子树的最左子节点*/
	int atLeft = 0, atRight = 0;

	/* 1. 找data对应的节点 */
	node = SearchBSTreeNode(root, data);
	if(NULL == node){
		printf("removeBSTreeNode can not find %d \n", data);
		return PARAM_ERR;
	}

	left = node->left;
	right = node->right;
	parent = node->parent;

	if(NULL != right){
		mostsubLeft = getMostLeftNode(right);
	}

	/* 非根节点 */
	if(NULL != parent){

		/*1. 摘下node和它的子树*/
		if(node->data < parent->data){
			parent->left = NULL;
			node->parent = NULL;
			atLeft = 1;
		} else {
			parent->right = NULL;
			node->parent = NULL;
			atRight = 1;
		}

		/*2. 挂子树*/
		
		/*node 是叶子节点，什么也不用做 */
		if(NULL == left && NULL == right){
		}

		/*非叶子节点*/

		/*有左子没右子*/
		if(NULL != left && NULL == right){ 
			if(1 == atLeft){
				parent->left = left;
				left->parent = parent;
			}  else if(1 == atRight) {
				parent->right = left;
				left->parent = parent;
			}
		}

		/*没左子有右子*/
		if(NULL == left &&  NULL != right){ 
			if(1 == atLeft){
				parent->left = right;
				right->parent = parent;
			}  else if(1 == atRight) {
				parent->right = right;
				right->parent = parent;
			}	
		}

		/*有左子有右子， 左子挂在右子的最左边节点的左边, 右子树根节点继承原来节点位置*/
		if(NULL != left && NULL != right){
			mostsubLeft->left = left;
			left->parent = mostsubLeft;
		
			if(1 == atLeft){
				parent->left = right;
				right->parent = parent;
			}  else if(1 == atRight) {
				parent->right = right;
				right->parent = parent;
			}	
			
		}
	} else { /* 根节点 */

		/*node 是叶子节点，什么也不用做 */
		if(NULL == left && NULL == right){
			root = NULL;
		}

		/*有左子没右子*/
		if(NULL != left && NULL == right){ 
			root = left;
		}

		/*没左子有右子*/
		if(NULL == left &&  NULL != right){ 	
			root = right;
		}		

		/*没左子有右子*/
		if(NULL == left &&  NULL != right){ 
			if(1 == atLeft){
				parent->left = right;
				right->parent = parent;
			}  else if(1 == atRight) {
				parent->right = right;
				right->parent = parent;
			}	
		}

		/*有左子有右子， 左子挂在右子的最左边节点的左边, 右子树根节点继承原来节点位置*/
		if(NULL != left && NULL != right){
			mostsubLeft->left = left;
			left->parent = mostsubLeft;
			/*更新根节点*/
			root = right;			
		}
		
		*proot = root;
	}

	free(node);
	node = NULL;

	return SUCCESS;
}


void testBSTree(void){

	printf("\n************  testBSTree ************ \n");

	st_trNode * p  = NULL;
	st_trNode * root = NULL;
	st_trNode * mostLeft = NULL;

	gBSTree = NULL;	
	createTree(&gBSTree);

	root = gBSTree->root;

	printf("insert 5\n");
	p = createTreeNode(5);		
	insertBSTNode(&root, p);

	printf("insert 3\n");
	p = createTreeNode(3);
	insertBSTNode(&root, p);

	printf("insert 7\n");
	p = createTreeNode(7);
	insertBSTNode(&root, p);

	printf("insert 2\n");
	p = createTreeNode(2);
	insertBSTNode(&root, p);

	printf("insert 4\n");
	p = createTreeNode(4);
	insertBSTNode(&root, p);

	printf("insert 6\n");
	p = createTreeNode(6);
	insertBSTNode(&root, p);

	printf("insert 8\n");
	p = createTreeNode(8);
	insertBSTNode(&root, p);

	printf("insert 1\n");
	p = createTreeNode(1);
	insertBSTNode(&root, p);


	gBSTree->root = root;
	dumpTree(gBSTree);

	p = NULL;
	p = SearchBSTreeNode(gBSTree->root, 5);
	if(NULL != p){
		printf("node[%p] = %d\n", p, p->data);
	} else {
		printf("Cannot find this node\n");
	}

	p = SearchBSTreeNode(gBSTree->root, 10);
	if(NULL != p){
		printf("node[%p] = %d\n", p, p->data);
	} else {
		printf("Cannot find this node\n");
	}

	p = SearchBSTreeNode(gBSTree->root, 8);
	if(NULL != p){
		printf("node[%p] = %d\n", p, p->data);
	} else {
		printf("Cannot find this node\n");
	}

	mostLeft = getMostLeftNode(gBSTree->root);
	if(NULL != mostLeft){
		printf("mostLeft[%p] = %d\n", mostLeft, mostLeft->data);
	} else {
		printf("Null Tree\n");
	}	

	mostLeft = getMostLeftNode(gBSTree->root->right);
	if(NULL != mostLeft){
		printf("mostLeft[%p] = %d\n", mostLeft, mostLeft->data);
	} else {
		printf("Null Tree\n");
	}	


	/*删除在最后测试*/
	root = gBSTree->root;
	//removeBSTreeNode(&root, 3);
	//removeBSTreeNode(&root, 1);	
	//removeBSTreeNode(&root, 4);
	//removeBSTreeNode(&root, 7);
	//removeBSTreeNode(&root, 8); /*删除右子树*/
	removeBSTreeNode(&root, 5); /*删除根节点*/
	gBSTree->root = root;
	dumpTree(gBSTree);	

	return;
}

代码编译

gcc main.c stack.c list.c tree.c -g -o a.exe -DDEBUG

调试输出


************  testBSTree ************
insert 5
1.1  root = 5
insert 3
1.6
1.2  left = 3, parent = 5
insert 7
1.7
1.5.1  root = 5
insert 2
1.7
1.4.2  root = 5, left = 3
1.6
1.2  left = 2, parent = 3
insert 4
1.7
1.4.2  root = 5, left = 3
1.7
1.5.1  root = 3
insert 6
1.7
1.5.2  root = 5, right = 7
1.6
1.2  left = 6, parent = 7
insert 8
1.7
1.5.2  root = 5, right = 7
1.7
1.5.1  root = 7
insert 1
1.7
1.4.2  root = 5, left = 3
1.7
1.4.2  root = 3, left = 2
1.6
1.2  left = 1, parent = 2
========= Dump Tree PreOder: 0x18ba010 ===========
         5  3  2  1  4  7  6  8
===================================
========= Dump Tree PreOder UnRec: 0x18ba010 ===========
         5  3  2  1  4  7  6  8
===================================
node[0x18ba030] = 5
Cannot find this node
node[0x18ba150] = 8
mostLeft[0x18ba180] = 1
mostLeft[0x18ba120] = 6
========= Dump Tree PreOder: 0x18ba010 ===========
         7  6  3  2  1  4  8
===================================
========= Dump Tree PreOder UnRec: 0x18ba010 ===========
         7  6  3  2  1  4  8
===================================

 

leoufung
关注
专栏目录
【数据结构与算法】二叉排序树C实现（含完整源码）
兰亭风雨的专栏
02-25 3万+
二叉排序树（Binary Sort Tree，简称BST），又称二叉查找树，是红黑树、AVL树等的基础。它或是一棵空树，或者是具有下列性质的一棵二叉树： 1、若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 2、若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值； 3、它的左右子树也分别为二叉排序树。 二叉排序树通常有查找、插入、删除等操作。查找操作很简单，无非就是递归查找，有点类似二叉树遍历的过程。插入操作也不难，一般是先在二叉排序树pTree中查找，看是
二叉排序树(C语言)
weixin_46503238的博客
07-26 944
二叉排序树
C语言二叉排序树
qq_58190943的博客
02-22 1445
插入算法： void InsertBFS(BSTree *a,Elemtype b) { if(!(*a))//*如果树为空 { BSTree c; c=(BSTree)malloc(sizeof(BSTNode)); c->lchild=c->rchild=NULL; c->data=b; *a=c; } else if(b.key<(*a)->data.key)//*如果插入的结点小于树结点 { InsertBFS(&(*a)-
二叉排序树（C语言版的！）.c
04-18
二叉排序树（C语言版的！）（1）二叉排序树存储定义 （2）从键盘上输入六个整数45、24、53、12、37、9构造二叉排序树 （3）输出其中序遍历结果。 （4）插入数据元素13，输出其中序遍历结果。 （5）删除数据元素24和53，输出其中序遍历结果。
【数据结构】树（五）—— 二叉排序树（C语言版）
热门推荐
haoweixl的博客
09-05 1万+
【数据结构】二叉排序树（C语言版）前言一、二叉排序树的定义二、二叉排序树的性质三、二叉排序树的操作二叉排序树常用存储结构二叉排序树的查找(递归实现)查找"二叉树T"中键值为 key 的节点(非递归实现)查找"二叉树T"中键值为 key 的节点二叉排序树的插入二叉排序树的创建二叉排序树的删除四、二叉树的查找性能分析应用区分：（与二分查找的应用区分）二叉排序树的构造树结构分析完整可运行代码 前言 二叉排序树(Binary Sort Tree,BST)又称为二叉查找树、二叉搜索树。与树型查找有关的结构有二叉排序树
判别二叉树是否为二叉排序树 -- C语言
六六哥的博客
02-23 1929
算法 使用中序遍历的结果就是排序二叉树的排序输出（从小到大）， 因此可以使用中序遍历 来实现判定二叉树是否为二叉排序树。 注意，不能用递归比较root和left，right的大小关系，因为left，right无法判断和root，root->parent,root->parent->parent等的大小关系 代码实现 bool isBSTree(st_trNode * ...
二叉排序树实现教师成果管理系统源码
01-09
总的来说，这个"教师成果管理系统"是一个结合了数据结构与文件操作的实用案例，它不仅展示了二叉排序树在实际问题中的应用，也锻炼了开发者在C语言环境下的编程能力。通过这个项目，学生可以深入理解二叉排序树的...
二叉排序树-非递归形式 C语言
qq_43402544的博客
10-22 1161
完整代码如下： #include <stdio.h> #include <stdlib.h> typedef struct BiTNode { int data;//二叉树数据域 struct BiTNode *lchild,*rchild;//二叉树指针域 }BiTNode,*BiTree; void InitTree(BiTree &T)//初始化二叉树 { T = (BiTNode*)malloc(sizeof(BiTNode));//创建一个头结点 .
二叉排序树（C语言）
02-03
程序实现二叉排序树，C语言入门小程序，适合C语言课程入门的小练习。 程序实现二叉排序树，C语言入门小程序，适合C语言课程入门的小练习。 程序实现二叉排序树，C语言入门小程序，适合C语言课程入门的小练习。
c语言程序构造二叉排序树,C语言实现二叉排序树的相关操作
weixin_35569158的博客
05-24 1328
本文链接：二叉排序树(Binary Sort Tree)c语言 二叉排序树，又称为二叉查找树。它或则是一颗空树，或者是带有以下性质的二叉树：构造二叉排序树的目的，并不是为了顺序，而是为了提升查找和插入删除关键字的速度。以下程序在DEV C++中安装运行通过。#include#include/*二叉树的二叉链表结点结构定义*/typedef struct BiTNode{int data;struc...
二叉排序树的操作（C语言实现）
01-08
本程序实现了二叉排序树的建立，插入和删除结点等操作，经调试无误
C语言实现数据结构 二叉排序树
05-08
C语言实现数据结构 二叉排序树C语言实现数据结构 二叉排序树C语言实现数据结构 二叉排序树C语言实现数据结构 二叉排序树
用C语言编写二叉排序树
06-21
有关二叉排序树的程序源代码，清楚的实现了如何让建立二叉排序树，怎样遍历二叉排序树，以及执行删除操作后的遍历。
二叉排序树-C语言
GoingJack博客
04-01 347
二叉排序树（BST）（二叉搜索树，二叉查找树）： 或者是一棵空树，或者是具有下列性质的二叉树： 1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 2. 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 3. 它的左、右子树也分别为二叉排序树。 //定义树的结构体 typedef struct BiNode { int data; stru...
c语言：二叉排序树的实现
在路上
05-22 1831
好长时间没更新博客了！ // 二叉排序树的实现最终版.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #include #define ElementType char using namespace std; typedef struct TreeNode *BinTree; typedef BinTree po
数据结构_排序二叉树(C语言)
小黯
03-22 3133
排序二叉树 1. 结构解析 排序二叉树的结构很简单，只遵循一个规则，那就是在二叉树中，选择任意根结点，其左子树都比根节点小，右子树都比根节点大。 排序二叉树的查找和插入操作理解都非常简单，只需要按照左小右大的规则即可完成查找和插入 观察如下排序二叉树，即可发现排序二叉树的规律，如图： 排序二叉树的删除操作较为难理解，删除操作一共分为三种情况（假设删除的结点为p，并且其父结点为f）： （1）当p结点的右子树不存在时，因为f的右子树都比f结点大，所以我们只需要将p的父结点指向p的指针指向p的左子树即可
C语言实现二叉排序树
qq_43148788的博客
03-02 2712
C语言实现二叉排序树
二叉排序树 C语言实现
Sungree的博客
09-22 2915
基础知识 二叉排序树，又称二叉搜索树(Binary search tree)，是一种拥有排序的二叉树结构。其特点有： 结点k的所有左子树结点，都小于等于结点k 结点k的所有右子树结点，都大于等于结点k k的子树也都是二叉排序树（递归） 显然，BST的中序遍历输出即为有序递增序列 二叉树的搜索，插入等操作是基于二分法的，所以时间复杂度为logn 二叉树的节点定义 typedef stru...
二叉树排序 --C语言数据结构
Andes Home 千年的塔 -十年技术，风雨兼程
08-20 3400
 #include #include typedef struct btree{ int data; struct btree *left; struct btree *right; }BTR,*PBTR;typedef struct BTRSt{  PBTR ptree;  struct BTRSt *link;}Stack,*PStack;PBTR Bitree=NULL;/*函数
C语言实现llink-rlink存储二叉排序树
"这篇代码示例展示了如何使用llink-rlink方式存储二叉排序树，并用C语言实现。代码包括创建、输入数据和输出数据的功能。" 二叉排序树（Binary Sort Tree，BST），又称为二叉查找树，是一种特殊的二叉树结构，其每...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值