数据结构第三部分：树与树的表示、二叉树及其遍历、二叉搜索树、平衡二叉树、堆、哈夫曼树、集合及其运算

int SequentialSearch(StaticTable * Tbl, ElementType K)
{
	// 在表Tbl[1]~Tbl[n] 中查找关键字为K的数据元素
	int i;
	Tabl->Element[0] = K; // 建立哨兵
	for(i = Tbl->Length; Tbl->Element[i] != K; i--)
		;
	return i; // 查找成功返回所在单元下标；不成功返回0
}

typedef struct TreeNode *BinTree;
typedef BinTree Position;
struct TreeNode{
	ElementType Data;
	BinTree Left;
	BinTree Right;
}

void PreOrderTraversal(BinTree BT)
{
	if(BT)
	{
		printf("%d", BT->data);
		PreOrderTraversal(BT->Left);
		PreOrderTraversal(BT->Right);
	}
}

void InOrderTraversal(BinTree BT)
{
	if(BT)
	{
		InOrderTraversal(BT->Left);
		printf("%d", BT->Data);
		InOrderTraversal(BT->Right);
	}
}

void PostOrderTraversal(BinTree BT)
{
	if(BT)
	{
		PostOrderTraversal(BT->Left);
		PostOrderTraversal(BT->Right);
		printf("%d", BT->Data);
	}
}

void InOrderTraversal(BinTree BT)
{
	BinTree T = BT;
	Stack S = CreateStack(MaxSize); // 创建并初始化堆栈
	while(T || !IsEmpty(S))
	{
		while(T) // 一直向左并将沿途结点压入堆栈
		{
			Push(S, T);
			T = T->Left;
		}
		if(!IsEmpty(S)) // 不是必须的，因为while入口处已经判断过了
		{
			T = Pop(S); // 结点弹出堆栈
			printf("%5d", T->Data); // (访问)打印结点
			T = T->Right; // 转向右子树
		}
	}
}

void LevelOrderTraversal(BinTree BT)
{
	Queue Q;
	BinTree T;
	if(!BT) // 若是空树直接返回
		return; 
	Q = CreateQueue(MaxSize); // 创建并初始化队列Q
	AddQ(Q, BT);
	while(!IsEmpty(Q))
	{
		T = Delete(Q);
		printf("%d\n", T->Data); // 访问取出队列的结点
		if(T->Left)
			AddQ(Q, T->Left);
		if(T->Right)
			AddQ(Q, T->Right);
	}
}

void PreOrderPrintLeaves(BinTree BT)
{
	if(BT)
	{
		if(!BT->Left && !BT->Right)
			printf("%d", BT->Data);
		PerOrderPrintLeaves(BT->Left);
		PerOrderPrintLeaves(BT->Right);
	}
}

int PostOrderGetHeight(BinTree BT)
{
	int HL, HR, MaxH;
	if(BT)
	{
		HL = PostOrderGetHeight(BT->Left); // 求左子树的深度
		HR = PostOrderGetHeight(BT->Right); // 求右子树的深度
		MaxH = (HL > HR) ? HL : HR; // 取左右子树中较大的深度
		return MaxH + 1; // 返回树的深度
	}
	else
		return 0; // 空树深度为0
}

Positon Find(ElementType X, BinTree BST)
{
	if(!BST)
		return NULL; // 查找失败
	if(X > BST->Data)
		return Find(X, BST->Right); // 在右子树中继续查找
	else if
		return Find(X, BST->Left); // 在左子树中继续查找
	else // X == BST->Data
		return BST; // 查找成功，返回结点的地址
}

Position IterFind(ElementType X, BinTree BST)
{
	while(BST)
	{
		if(X > BST->Data)
			BST = BST->Right; // 向右子树中移动，继续查找
		else if(X < BST->Data)
			BST = BST->Left; // 向左子树中移动，继续查找
		else // X == BST->Data
			return BST; // 查找成功，返回结点的地址
	}
	return NULL; // 查找失败
}

Postion FindMin(BinTree BST)
{
	if(!BST)
		return NULL; // 空的二叉搜索树，返回NULL
	else if(!BST->Left)
		return BST; // 找到最左叶结点并返回
	else 
		return FindMin(BST->Left); // 沿左分支继续查找
}

Position FindMax(BinTree BST)
{
	if(BST)
		while(BST->Right)
			BST = BST->Right; // 沿右分支继续查找，直到最右结点
	return BST;
}

BinTree Insert(ElementType X, BinTree BST)
{
	if(!BST)
	{
		// 若原树为空，生成并返回一个结点的二叉搜索树
		BST = malloc(sizeof(struct TreeNode));
		BST->Data = X;
		BST->Left = BST->Right = NULL;
	}
	else // 开始找要插入元素的位置
	{
		if(X < BST->Data)
			BST->Left = Insert(X, BST->Left); // 递归插入左子树
		else if(X > BST->Data)
			BST->Right = Insert(X, BST->Right); // 递归插入右子树
		// else X已经存在，什么都不做
	}
	return BST;
}

BinTree Delete(ElementType X, BinTree BST)
{
	Position Tmp;
	if(!BST)
		printf("要删除的元素未找到");
	else if(X < BST->Data)
		BST->Left = Delete(X, BST->Left); // 左子树递归删除
	else if(X > BST->Data)
		BST->Right = Delete(X, BST->Right); // 右子树递归删除
	else // 找到要删除的结点
	{
		if(BST->Left && BST->Right) // 被删除结点有左右两个子结点
		{
			Tmp = FindMin(BST->Right); // 在右子树中找最小的元素填充删除结点
			BST->Data = Tmp->Data;
			BST->Right = Delete(BST->Data, BST->Right); // 在删除结点的右子树中删除最小元素
		}
		else // 被删除结点有一个或无子结点
		{
			Tmp = BST;
			if(!BST->Left) // 有右孩子或无子结点
				BST = BST->Right;
			else if(!BST->Right) // 有左孩子或无子结点
				BST = BST->Left;
			free(Tmp);
		}
	}
	return BST;
}

typedef struct AVLTreeNode *AVLTree;
typedef struct AVLTreeNode{
	ElementType Data;
	AVLTree Left;
	AVLTree Right;
	int Height;
};

AVLTree AVL_Insertion(ELementType X, AVLTree T)
{
	// 将X插入AVL树中，并且返回调整后的AVL树
	if(!T) // 若插入空树，则新建一个包含一个结点的树
	{
		T = (AVLTree) malloc(sizeof(struct AVLTreeNode));
		T->Data = X;
		T->Height = 0;
		T->Left = T->Right = NULL;
	} // if(插入空树)结束
	else if(X < T->Data) // 插入T的左子树
	{
		T->Left = AVL_Insertion(X, T->Left);
		if(GetHeight(T->Left) - GetHeight(T->Right) == 2)
		{
			// 需要左旋
			if(X < T->Left->Data)
				T = SingleLeftRotation(T); // 左单旋
			else
				T = DoubleLeftRightRotation(T); // 左-右双旋
		}
	} // else if(插入左子树)结束
	else if(X > T->Data) // 插入T的右子树
	{
		T->Right = AVL_Insertion(X, T->Right);
		if(GetHeight(T->Left) - GetHeight(T->Right) == -2)
		{
			// 需要右旋
			if(X > T->Right->Data)
				T = SingleRightRotation(T); // 右单旋
			else
				T = DoubleRightLeftRotation(T); // 右-左双旋
		}
	} //else if(插入右子树)结束
	
	// else X == T->Data, 无须插入
	
	T->Height = Max(GetHeight(T->Left), GetHeight(T->Right)) + 1; // 更新树高
	
	return T; 
}

AVLTree SingleLeftRotation(AVLTree A)
{
	// 注意：A必须有一个左子结点B
	// 将A与B做如图所示的左单旋，更新A与B的高度，返回新的根结点B
	AVLTree B = A->Left;
	A->Left = B->Right;
	B->Right = A;
	A->Height = Max(GetHeight(A->Left), GetHeight(A->Right)) + 1;
	B->Height = Max(GetHeight(B->Left), A->Height) + 1;
	
	return B;
}

AVLTree DoubleLeftRightRotation(AVLTree A)
{
	// 注意：A必须有一个左子结点B，且B必须有一个右子结点C
	// 将A、B与C做如图所示的两次单旋，返回新的根结点C
	A->Left = SingleRightRotation(A->Left); // 将B与C做右单旋，C被返回
	
	return SingleLeftRotationO(A); // 将A与C做左单旋，C被返回
}

typedef struct HeapStruct *MaxHeap;
struct HeapStruct{
	ElementType *Elements; // 存储堆元素的数组
	int Size; // 堆的当前元素个数
	int Capacity; // 堆的最大容量
}

MaxHeap Create(int MaxSize)
{
	// 创建容量为MaxSize的空的最大堆
	MaxHeap H = malloc(sizeof(struct HeapStruct));
	H->Elements = malloc((MaxSize+1) * sizeof(ElementType));
	H->Size = 0;
	H->Capacity = MaxSize;
	H->Elements[0] = MaxData; // 定义"哨兵"为大于堆中所有可能元素的值，便于以后更快操作
	return H;
}

void Insert(MaxHeap H, ElementType item)
{
	// 将元素item插入最大堆H，其中H->Elements[0]已经定义为哨兵
	int i;
	if(IsFull(H))
	{
		printf("最大堆已满");
		return;
	}
	i = ++H->Size; // i指向插入后堆中的最后一个元素的位置
	for(; H->Elements[i/2] < item; i /= 2)
		H->Elements[i] = H->Elements[i/2]; // 向下过滤结点，这种方式比交换数据来得快
	H->Elements[i] = item; // 将item插入
}

ElementType DeleteMax(MaxHeap H)
{
	// 从最大堆H中取出键值为最大的元素，并删除一个结点
	int Parent, Child;
	ElementType MaxItem, temp;
	if(IsEmpty(H))
	{
		printf("最大堆已为空");
		return;
	}
	MaxItem = H->Elements[1]; // 取出根结点最大值
	// 用最大堆中最后一个元素从根结点开始向上过滤下层结点
	temp = H->Elements[H->Size--];
	for(Parent = 1; Parent*2 <= H->Size; Parent = Child)
	{
		Child = Parent*2;
		if((Child != H->Size) && (H->Elements[Child] < H->Elements[Child+1]))
			Child++; // Child指向左右子结点中的较大者
		if(temp >= H->Elements[Child])
			break;
		else // 移动temp元素到下一层
			H->Elements[Parent] = H->Elements[Child];
	}
	H->Elements[Parent] = temp;
	return MaxItem;
}

typedef struct TreeNode *HuffmanTree;
struct TreeNode{
	int Weight;
	HuffmanTree Left, Right;
}
HuffmanTree Huffman(MinHeap H)
{
	// 假设H->Size个权值已经存在H->Elements[]->Weight里
	int i;
	HuffmanTree T;
	BuildMinHeap(H); // 将H->Elements[]按权值调整为最小堆
	for(i = 1; i < H->Size; i++) // 做H->Size-1次合并
	{
		T = malloc(sizeof(struct TreeNode)); // 建立新结点
		T->Left = DeleteMin(H); // 从最小堆中删除一个结点，作为新T的左子结点
		T->Right = DeleteMin(H); // 从最小堆中删除一个结点，作为新T的右子结点
		T->Weight = T->Left->Weight + T->Right->Weight; // 计算新权值
		Insert(H, T); // 将新T值插入最小堆
	}
	T = DeleteMin(H);
	return T; 
}

typedef struct{
	ElementType Data;
	int Parent;
}SetType;

int Find(SetType S[], ElementType X)
{
	// 在数组中查找值为X的元素所属的集合
	// MaxSize是全局变量，为数组S的最大长度
	int i;
	for(i = 0; i < MaxSize && S[i].Data != X; i++)
		;
	if(i >= MaxSize)
		return -1; // 未找到X，返回-1
	for(; S[i].Parent >= 0; i = S[i].Parent)
		;
	return i; // 找到X所属集合，返回数根结点在数组S中的下标
}

void Union(SetType S[], ElementType X1, ElementType X2)
{
	int Root1, Root2;
	Root1 = Find(S, X1);
	Root2 = Find(S, X2);
	if(Root1 != Root2)
		S[Root2].Parent = Root1;
}