数据结构(四)

树

数是一种非线性的数据结构，这也是和我们之前了解的链表，栈，队列等结构不同的地方。

树的概念：1.只能有一个节点为根，且这个根不能有前驱节点

                  2.子树之间不能相连

节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为6
叶节点或终端节点：度为0的节点称为叶节点； 如上图：B、C、H、I...等节点为叶节点
非终端节点或分支节点：度不为0的节点； 如上图：D、E、F、G...等节点为分支节点
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； 如上图：A是B的父节点
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 如上图：B是A的孩子节点
兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图：B、C是兄弟节点
树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为6
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次； 如上图：树的高度为4
堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点
节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
森林：由m（m>0）棵互不相交的树的集合称为森林；

 树的表示：

常用的是孩子兄弟表示法（左孩子右兄弟表示法）

typedef int DataType
struct Node
{
  DateType date;

  struct Node* firstChild;

  struct Node* NextBrother;
}

二叉树

这是一颗二叉树，由上图可以分析出他的特点：

1. 二叉树不存在度大于2的结点
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

特殊的二叉树：

数组存储二叉树

二叉树是一种有序树，利用这个特点就可以将二叉树存储在数组中

将二叉树上的节点对应数组中的下标，就可以将这颗二叉树看作一个数组，物理上是数组，逻辑上还是二叉树。

数组中的下表使二叉树中个个节点相互关联

parent = (child-1)/2  

leftchild = parent*2 + 1

rightchild = parent*2 + 2

但是并不是所有的二叉树都是满二叉树，对于非满二叉树数的存储十分困难。

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储

堆

定义：由一组数按照完全二叉树存储在数组中的方法来进行存储，并满足，父节点一定大于或小于子节点就叫做堆。

分类：父节点大于子节点叫大堆    父节点小于子节点叫小堆

特点：逻辑结构是二叉树    存储结构是数组

堆的插入，对的存储结构是一个数组，所以堆的插入很简单，思路是先检查对空间中的空间是否足够不足我们先进行扩容，然后插入。

插入数据后会破坏我们的堆结构，所以我们要重新调整这个堆，这里有两种调整方式，向上调整和向下调整

//向上调整
//以小堆为例
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])//变大堆改变符号即可a[child] > a[parent]
		{
			Swap(&a[parent], &a[child]);
			child = parent;
			parent = (parent - 1) / 2;
		}
		else
			break;
	}
}

//向下调整
//以小堆为例
void AdjustDown(HPDataType* a, int size,int parent)
{
	//默认左孩子比右孩子小
	int child = parent * 2 + 1;
	while(child < size)
	{
		
		if (a[child + 1] < a[child])//如果右孩子更小则指向右孩子
		{
			child++;
		}
		if (a[child] < a[parent])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = child * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//堆插入
// 插入后保持数据是堆，所以插入后需要调整
void HPPush(HP* php, HPDataType x)
{
	assert(php);
	//插入前先看看堆内有没有空间
	if (php->_capacity == php->_size)//空间不足扩容
	{
		int newcapcity = (php->_capacity == 0 ? newcapcity = 4 : php->_capacity * 2);
		HPDataType* tmp = (HPDataType*)realloc(php->_a ,sizeof(HPDataType) * newcapcity);

		php->_a = tmp;
		php->_capacity = newcapcity;
	}
	//size是最后一个数据的下一个位置，有10个数据最后一个数据的下标为9，一共有size个数据，所有数据的下标为0到size-1
	php->_a[php->_size] = x;
	php->_size++;
	AdjustUp(php->_a , php->_size - 1);//这里的size-1为插入数据的下标
}

//直接给定一个数组并建堆
void HPInitArray(HP* php, HPDataType* a, int n)
{
	assert(php);
	
	php->_a = (HPDataType*)malloc(sizeof(HPDataType)*n);
	if (php->_a == NULL)
	{
		perror("malloc fail");
		return;
	}
	memcpy(php->_a ,a, sizeof(HPDataType) * n);//复制数组内容
	php->_capacity = php->_size = n;//复制数组大小

	//对这个堆调整
	// 向上调整，建堆 O(N*logN)
	for (int i = 1; i < php->_size; i++)
	{
		AdjustUp(php->_a, i);
	}
	//向下调整
	for (int i = (php->_size-1-1)/2; i>=0; i--)
	{
		AdjustDown(php->_a,php->_size ,i);
	}

}

堆排序

//建小堆，得降序
//建大堆，得升序
void HeapSort(int* a, int n)//n是数组元素个数
{
	//a数组直接建堆
	for (int i = (n-1-1)/2;i>=0;i-- )
	{
		AdjustDown(a, n, i);
	}

	int end = n - 1;
	while (end > 0)
	{
		Swap(a[0], a[end]);
		AdjustDown(a,end,0);
		end--;
	}
}

 堆排序算法示意图

链表存储二叉树

链表则是二叉树主要存储方式

前序，中序，后续遍历

二叉树作为一种数据结构，那么对于存储的这些数据我们怎么去遍历好呢，对于一棵树中的数据会有多种的遍历方式。

一棵树大概可以分为三个部分，根，左子树，右子树。遍历时只要遍历了这三个部分就遍历了整个树，针对这三个部分我们分出了三种遍历方式(这些遍历方式都与递归思想密不可分)。

前序：根  左子树  右子树

中序：左子树  根  右子树

后序：左子树  右子树  根    

中序和后序类同于前序

void BinaryTreePrevOrder(BTNode* root)// 根  左子树  右子树
{
	//assert(root);
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	printf("%d ",root->_data);
	BinaryTreePrevOrder(root->_left);
	BinaryTreePrevOrder(root->_right);

}
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N");
		return;
	}
	BinaryTreePrevOrder(root->_left);
	printf("%d", root->_data);
	BinaryTreePrevOrder(root->_right);
}
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N");
		return;
	}
	BinaryTreePrevOrder(root->_left);
	BinaryTreePrevOrder(root->_right);
	printf("%d", root->_data);
}

层序遍历

借助栈来实现，从根开始进栈，父节点出两个子节点进

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)//栈
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePop(&q, root);
	while (!QueueEmpty(&q))
	{
		if (root)
		{
			printf("%d ", front->val);
			QueuePush(&q, foront->left);
			QueuePush(&q, foront->right);
		}
		else
			printf("N ");
	}
}

判断完全二叉树

// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q); 
	if (root)
		QueuePush(&q, root);
	while (!QueueEmpty())
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front == NULL)
			break;
	}
	QueueDestry(&q);
}