数据结构---二叉树---顺序结构实现

 树的概念与结构

 • 有⼀个特殊的结点，称为根结点，根结点没有前驱结点。

 • 除根结点外，其余结点被分成 M(M>0) 个互不相交的集合 T1、T2、……、Tm ，其中每⼀个集合Ti(1 <= i <= m) ⼜是⼀棵结构与树类似的⼦树。每棵⼦树的根结点有且只有⼀个前驱，可以有 0 个或多个后继。因此，树是递归定义的。

树相关术语
 

⽗结点/双亲结点：

若⼀个结点含有⼦结点，则这个结点称为其⼦结点的⽗结点； 如上图：A是B的⽗结点

⼦结点/孩⼦结点：

⼀个结点含有的⼦树的根结点称为该结点的⼦结点； 如上图：B是A的孩⼦结点结点的度：⼀个结点有⼏个孩⼦，他的度就是多少；⽐如A的度为6，F的度为2，K的度为0

树的度：

⼀棵树中，最⼤的结点的度称为树的度； 如上图：树的度为 6

叶⼦结点/终端结点：

度为 0 的结点称为叶结点； 如上图： B、C、H、I... 等结点为叶结点 分⽀结点/⾮终端结点：度不为 0 的结点； 如上图： D、E、F、G... 等结点为分⽀结点 兄弟结点：具有相同⽗结点的结点互称为兄弟结点(亲兄弟)； 如上图： B、C 是兄弟结点

结点的层次：

从根开始定义起，根为第 1 层，根的⼦结点为第 2 层，以此类推；树的⾼度或深度：树中结点的最⼤层次； 如上图：树的⾼度为 4

结点的祖先：

从根到该结点所经分⽀上的所有结点；如上图： A 是所有结点的祖先

路径：

⼀条从树中任意节点出发，沿⽗节点-⼦节点连接，达到任意节点的序列；⽐如A到Q的路径为： A-E-J-Q；H到Q的路径H-D-A-E-J-Q⼦孙：以某结点为根的⼦树中任⼀结点都称为该结点的⼦孙。如上图：所有结点都是A的⼦孙

森林：

由 m（m>0） 棵互不相交的树的集合称为森林；

树的表示法

兄弟孩子表示法

*child,      *brother;

二叉树 

满二叉树

完全二叉树

⼆叉树性质

根据满⼆叉树的特点可知：

1）若规定根结点的层数为 1 ，则⼀棵⾮空⼆叉树的第i层上最多有 2i-1 个结点

2）若规定根结点的层数为 1 ，则深度为 h 的⼆叉树的最⼤结点数是 2h - 1

3）若规定根结点的层数为 1 ，具有 n 个结点的满⼆叉树的深度 ( log以2为底， n+1 为对数)

 

 

 

二叉树的存储结构 

顺序结构

arr[ ]={ };

链式结构

二叉树二叉链表:左右指针,*left, *right

二叉树三叉链表:左上右指针,

 实现顺序结构二叉树

⼀般堆使⽤顺序结构的数组来存储数据，堆是⼀种特殊的⼆叉树，具有⼆叉树的特性的同时，还具备其他的特性。

堆:

一种特殊的二叉树

1.------大堆(大根堆)

2.------小堆(小根堆)

 

堆的性质

                                                child: i<------->parend:(i-1)/2

 

实现堆的结构 

初始化堆

定义一个堆

//定义堆的结构---数组

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* arr;
	int size;//有效的数据个数
	int capacity;//空间大小
}HP;

初始化

void HPInit(HP* php);

void HPInit(HP* php)
{
	assert(php);
	php->arr = NULL;
	php->size = php->capacity = 0;
}

---

 

 销毁

void HPDestroy(HP* php);

void HPDestroy(HP* php)
{
	assert(php);
	if (php->arr)
		free(php->arr);

	php->arr = NULL;
	php->size = php->capacity = 0;
}

---

 

 判空

// 判空
bool HPEmpty(HP* php);

// 判空
bool HPEmpty(HP* php)
{
	assert(php);
	return php->size == 0;
}

HPDataType HPTop(HP* php)
{
	assert(php && php->size);

	return php->arr[0];
}

 

---

交换数值 

void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

 

---

 

 堆的插入

size=capacity时,内存已满

2倍扩容            申请空间HPDataType*tmp

if  (tmp=NULL,满了,申请不了

php->arr = tmp;

将 tmp 中的新内存地址赋值给 php->arr，这样 php->arr 就指向了扩展后的数组

tmp给arr,capacity更新

在size位置插入

​//堆的插入
void HPPush(HP* php, HPDataType x)
{
	assert(php);
	//判断空间是否足够
	if (php->size == php->capacity)
	{
		//扩容
		int newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = (HPDataType*)realloc(php->arr, newCapacity * sizeof(HPDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		php->arr = tmp;
		php->capacity = newCapacity;
	}
	php->arr[php->size] = x;
	
	AdjustUp(php->arr, php->size);

	++php->size;
}

​

堆顶的删除

删除堆顶不能用顺序表的方法,删除第一位,整体向前挪,因为可能不是小根堆,其次效率低

堆顶与堆尾交换 10<----->70

堆尾删除10;

堆顶向下调整算法

不断交换,跟child值小的交换

直到child==parent

void HPPop(HP* php)
{
	assert(php && php->size);

	//arr[0]  arr[size-1]
	Swap(&php->arr[0], &php->arr[php->size - 1]);

	--php->size;

	AdjustDown(php->arr, 0, php->size);

	
}

---

 

向上调整算法 

向小堆插入6

child

parent=(child-1)/2

小堆

child比parent小,交换

child移动到parent位置

parent指针指向child的新parent

​//向上调整算法
void AdjustUp(HPDataType* arr,int child)
{
	int parent = (child - 1) / 2;

	while (child > 0)//不需要等于，child只要走到根节点的位置，根节点没有父节点不需要交换
	{
		if (arr[child] < arr[parent])
		{
			Swap(&arr[parent], &arr[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
	
}

​

---

向下调整算法

 

void AdjustDown(HPDataType* arr, int parent, int n)
{
	int child = parent * 2 + 1;//左孩子
	//while (parent < n)
	while (child < n)
	{
		//找左右孩子中找最小的
		if (child + 1 < n && arr[child] > arr[child + 1])
		{
			child++;
		}
		if (arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;

		}
		else
		{
			break;
		}
	}
}