数据结构之二叉树

二叉树

二叉树是一种常用的数据结构。

1、什么是二叉树？
1.1 什么是树型结构？

树形结构是一层次的嵌套结构。 一个树形结构的外层和内层有相似的结构， 所以这种结构多可以递归的表示。经典数据结构中的各种树状图是一种典型的树形结构：一颗树可以简单的表示为根， 左子树， 右子树。 左子树和右子树又有自己的子树。

1.2 什么是二叉树？

二叉树是树型结构的最简化模型，每个节点最多有两个子节点。

2、二叉树有什么用？

二叉树可以做搜索，它的搜索速度比较快，logn级别，当然也有其他的用处，比如排序。  

3、二叉树的结构

二叉树的节点结构体包括一个数据和两个指针，一个指针指向左节点，一个指针指向右节点。二叉树的结构体包含一个储存大小的整数类型和一个指针，指针指向树的根节点。

4、有序二叉树的实现

4.1 什么是有序二叉树？

对于树中任意节点，若其左子树非空，则左子树中所有节点的值，都小于或等于该节点的值，若其右子树非空，则右子树中所有节点的值都大于或等于该节点的值。（左小右大）则该树称为有序二叉树，也叫二叉搜索树。

 

4.2 基础的操作

1、初始化

2、销毁

3、插入

4、擦除一个指定数据

5、擦除所有指定数据

6、清空树

7、判断指定数据是否存在

8、遍历树

9、获取树的大小

4.3 笔记

这是我在观看视频的时候写的笔记

一、二叉树

1、树型结构的最简化模型，每个节点最多有两个子节点。

2、有父节点没有子节点的点，称为叶节点

    有父节点有子节点，称为支节点

   无父节点的，称为根节点

 

3、二叉树的特性：

单根性：除了根节点以外的每个节点都有父节点，整棵树有且仅有一个根节点。

递归性：以二叉树的任意一个节点为根，都可以构成一个二叉树。

 

4、遍历序

1）前序遍历：D-L-R先访问数据，在访问左子树，再访问右子树。

2）中序遍历：L-D-R

3）后序遍历: L-R-D

 

5、形式表示：根节点、枝节点、叶节点、父节点、子节点、左子节点、

右子节点、高度（深度）、宽度（广度）。

 

6、满二叉树

除了叶节点，每个节点都有两个子节点。

 

7、完全二叉树：

并不满，除了最下一层，其他层都达到满的状态。同时，最下层的节点

集中在左侧。

 

8、存储结构

1）顺序存储

使用数组存，从上到下，从左到右，依次存放。

非完全树要将虚结点补全成完全树，会浪费空间

 

2）链式存储：二叉链表、三叉链表

拓扑结构符合。

二叉链表：每个节点有两个指针，分别指向左子节点，右子节点，还有一个

数据

三叉链表：每个节点有三个指针，分别指向左子节点，右子节点，以及父节

点，外加一个数据。

 

9、有序二叉树（二叉搜索树）

1）对于树中任意节点，若其左子树非空，则左子树中所有节点的值，都小于

或等于该节点的值，若其右子树非空，则右子树中所有节点的值都大于或等

于该节点的值。（左小右大）则该树称为有序二叉树。

 

有序二叉树 +中序遍历 得到升序序列，排序性能好

搜索：o(logN)

树搜索快，构建慢。

4.4 基于链表的有序二叉树的c语言实现

头文件

/*create a tree*/
#ifndef _BT_H
#define _BT_H
#include <sys/types.h>
#include <stdbool.h>
/*node*/
typedef struct BsTreeNode{
	int data;
	struct BsTreeNode* left;
	struct BsTreeNode* right;
	
}BSTREE_NODE;

typedef struct BsTree{
	BSTREE_NODE* root;
	size_t size;
}BSTREE;

/*init to a empty tree*/
void bstree_init(BSTREE* bstree);

/*free rest node,and init*/
void bstree_deinit(BSTREE* bstree);

/*insert*/
void bstree_insert(BSTREE* bstree,int data);

/*delete*/
bool bstree_erase(BSTREE* bstree,int data);

/*delete all the right data*/
void bstree_remove(BSTREE* bstree,int data);

/*clear*/
void bstree_clear(BSTREE* bstree);

/*updata*/
void bstree_updata(BSTREE* bstree,int old, int _new);

/*there are ?*/
bool bstree_exist(BSTREE* bstree,int data);

/**/
void bstree_travel(BSTREE* bstree);

/*how many */
size_t bstree_size(BSTREE* bstree);

/*height*/
size_t bstree_height(BSTREE* bstree);
#endif/*_BT_H*/

 

C文件

#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include "bt.h"
/*internal interface*/

/*create a node*/
static BSTREE_NODE* create_node(int data){
	BSTREE_NODE* node=malloc(sizeof(BSTREE_NODE));
	node->data=data;
	node->left=NULL;
	node->right=NULL;
	return node;
}
/*delete node*/
static void destroy_node(BSTREE_NODE* node){
	free(node);
};

/*insert node to a tree base on root*/
static void insert(BSTREE_NODE* node,BSTREE_NODE** root){
	if(!*root)
		*root=node;
	else if(node)
		if(node->data<(*root)->data)
			insert(node,&(*root)->left);
		else
        	insert(node,&(*root)->right);

};

/*return the tree based on root ,...*/
static BSTREE_NODE** find(int data,BSTREE_NODE** root){
	if(!*root)
		return root; /*find failed*/
	if(data<(*root)->data)
		return find(data,&(*root)->left);
	if(data>(*root)->data)
		return find(data,&(*root)->right);
	return root;/*find success*/
}

/*clear all*/
static void clear(BSTREE_NODE** root){
	if(*root){
		clear(&(*root)->left);
		clear(&(*root)->right);
		destroy_node(*root);
		*root=NULL;
	}
}

/*travel */
static void travel(BSTREE_NODE* root){
	if(root)
	{
		travel(root->left);
		printf("%d ",root->data);
		travel(root->right);
//		printf("%d ",);
	}
}

/*return height*/
static size_t height(BSTREE_NODE* root){
	if(root){
		size_t lh=height(root->left);
		size_t rh=height(root->right);
		return (lh>rh?lh:rh)+1;
	}
	return 0;
}
/*external interface */

/*init to a empty tree*/
void bstree_init(BSTREE* bstree){
	bstree->root=NULL;
	bstree->size=0;
}

/*free rest node,and init*/
void bstree_deinit(BSTREE* bstree){
	clear(&bstree->root);
	bstree->size=0;
}

/*insert*/
void bstree_insert(BSTREE* bstree,int data){
	insert(create_node(data),&bstree->root);
	++bstree->size;
};

/*delete*/
bool bstree_erase(BSTREE* bstree,int data){
	BSTREE_NODE** node=find(data,&bstree->root);
	if(*node){
		insert((*node)->left,&(*node)->right);
		BSTREE_NODE* temp=*node;
		*node=(*node)->right;

		destroy_node(temp);
		--bstree->size;
		return true;
	}
	return false;
}

/*delete all the right data*/
void bstree_remove(BSTREE* bstree,int data){
	while(bstree_erase(bstree,data));
}

/*clear*/
void bstree_clear(BSTREE* bstree){
	bstree_deinit(bstree);
}

/*updata*/
void bstree_updata(BSTREE* bstree,int _old, int _new){
	while(bstree_erase(bstree,_old))
		bstree_insert(bstree,_new);
}

/*there are ?*/
bool bstree_exist(BSTREE* bstree,int data){
	return *find(data,&bstree->root)!=NULL;
}

/**/
void bstree_travel(BSTREE* bstree){
	travel(bstree->root);
	printf("\n");
}

/*how many */
size_t bstree_size(BSTREE* bstree){
	return bstree->size;
}

/*height*/
size_t bstree_height(BSTREE* bstree){
	return height(bstree->root);
}

 

测试文件

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

int main(void){
	srand(time(NULL));
	BSTREE bstree;
	bstree_init(&bstree);
	for(int i=0;i<10;i++)
		bstree_insert(&bstree,rand()%100);
	bstree_travel(&bstree);
	bstree_clear(&bstree);

	bstree_insert(&bstree,50);
	bstree_insert(&bstree,70);
	bstree_insert(&bstree,20);
	bstree_insert(&bstree,60);
	bstree_insert(&bstree,40);
	bstree_insert(&bstree,30);
	bstree_insert(&bstree,10);
	bstree_insert(&bstree,90);
	bstree_insert(&bstree,80);

	bstree_travel(&bstree);

	printf("members:%u\n height:%u\n",bstree_size(&bstree),bstree_height(&bstree));

	bstree_erase(&bstree,20);
	bstree_travel(&bstree);

	bstree_insert(&bstree,70);
	bstree_insert(&bstree,70);
	bstree_updata(&bstree,70,200);
	bstree_travel(&bstree);
   
	bstree_remove(&bstree,200);
	bstree_travel(&bstree);
	
	if(bstree_exist(&bstree,20))
		printf("20 is in\n");
	else
		printf("20 isn't in\n");

	

	bstree_deinit(&bstree);
}