数据结构（链式二叉树及快速排序的算法实现）

链式二叉树的算法实现

算法实现的目标：动态构造一个链式二叉树、并且用先序、中序、后序遍历这个链式二叉树。
一个结点包括三个部分：左孩子的指针域、数据域、右孩子的指针域。
所以创建链式二叉树的步骤为：把左指针域指向他的左孩子，右指针域指向他的右孩子。

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

typedef struct BTNode {
	char data;
	struct BTNode *pLchild; // p是指针 L是左 child是孩子
	struct BTNode * pRchild; 
}BTNODE, *PBTNODE;

PBTNODE CreateBTree(void);
void PreTraverseBTree(PBTNODE);
void InTraverseBTree(PBTNODE);
void PostTraverseBTree(PBTNODE);

int main(void)
{
	PBTNODE pT = CreateBTree();
	printf("先序遍历结果：");
	PreTraverseBTree(pT);
	printf("\n中序遍历结果：");
	InTraverseBTree(pT);
	printf("\n后序遍历结果：");
	PostTraverseBTree(pT);
} 

PBTNODE CreateBTree(void)
{
	// 动态创建A、B、C、D、E五个结点 
	PBTNODE pA = (PBTNODE)malloc(sizeof(BTNODE));
	PBTNODE pB = (PBTNODE)malloc(sizeof(BTNODE));
	PBTNODE pC = (PBTNODE)malloc(sizeof(BTNODE));
	PBTNODE pD = (PBTNODE)malloc(sizeof(BTNODE));
	PBTNODE pE = (PBTNODE)malloc(sizeof(BTNODE));
	
	// 给每一个结点的数据域赋值 
	pA->data = 'A';
	pB->data = 'B';
	pC->data = 'C';
	pD->data = 'D';
	pE->data = 'E';
	
	// 给每一个结点的左指针域和右指针域指向它们的下一个结点 
	pA->pLchild = pB;
	pA->pRchild = pC;
	pB->pLchild = pB->pRchild = NULL;
	pC->pLchild = pD;
	pC->pRchild = NULL;
	pD->pLchild = NULL;
	pD->pRchild = pE;
	pE->pLchild = pE->pRchild = NULL;
	
	// 返回根结点 
	return pA;
}

void PreTraverseBTree(PBTNODE pT)
{
	/*
		先访问根结点
		再先序遍历左子树
		再先序遍历右子树 
	*/
	
	if (NULL != pT) {
		printf("%c ", pT->data); // 先访问根结点
		
		if (NULL != pT->pLchild) {
			PreTraverseBTree(pT->pLchild); //再先序遍历左子树
		}
		
		if (NULL != pT->pRchild) {
			PreTraverseBTree(pT->pRchild); //再先序遍历右子树
		}
	}
}

void InTraverseBTree(PBTNODE pT)
{
	/*
		先中序遍历左子树
		再访问根结点
		再中序遍历右子树 
	*/
	
	if (NULL != pT) {
		
		if (NULL != pT->pLchild) {
			InTraverseBTree(pT->pLchild);  //先中序遍历左子树
		}
		
		printf("%c ", pT->data); // 再访问根结点
		
		if (NULL != pT->pRchild) {
			InTraverseBTree(pT->pRchild);  // 再中序遍历右子树  
		}
	}
}

void PostTraverseBTree(PBTNODE pT)
{
	/*
		先后序遍历左子树
		再后序遍历右子树 
		再访问根结点
	*/
	
	if (NULL != pT) {
		
		if (NULL != pT->pLchild) {
			PostTraverseBTree(pT->pLchild); // 先后序遍历左子树
		}
		
		if (NULL != pT->pRchild) {
			PostTraverseBTree(pT->pRchild); // 再后序遍历右子树
		}
		
		printf("%c ", pT->data); // 再访问根结点
	}
}

查找和排序

（1）折半查找
（2）排序：冒泡、插入、选择、快速排序、归并排序
排序和查找的关系：排序是查找的前提，排序是重点。

排序排序算法实现

# include <stdio.h>

void QuickSort(int *a, int low, int hight);
int FindPos(int *, int, int);

int main(void)
{
	int a[6] = {2, 1, 0, 5, 4, 3};
	int i;
	 
	QuickSort(a, 0, 5); //第一个参数表示第一个元素的下标，第二个元素的下标表示最后一个元素的下标 
	
	for (i=0; i<6; ++i)
		printf("%d ", a[i]);
	printf("\n");
	
	return 0;	
} 

void QuickSort(int *a, int low, int hight)
{
	int pos;
	
	if (low < hight) {
		pos = FindPos(a, low, hight);
		QuickSort(a, low, pos-1);
		QuickSort(a, pos+1, hight);
	}
}

int FindPos(int *a, int low, int hight)
{
	int val = a[low];
	
	while (low < hight) {
		while (low<hight && a[hight]>=val)
			--hight;
		a[low] = a[hight];
		
		while (low<hight && a[low]<=val)
			++low;
		a[hight] = a[low];
	} // 终止while循环之后low和hight一定相等 
	a[low] = val;
	
	return hight; // hight可以改为low，但不能改为val a[low]; 
}

再次讨论什么是数据结构

数据结构研究的是数据的存储和数据的操作的一门学问
数据的存储分为两部分：
个体的存储和个体关系的存储
从某个角度而言，数据的存储最核心的就是个体关系的存储，个体的存储可以忽略不计

再次讨论什么是泛型

同一种逻辑结构，无论该逻辑结构物理存储是什么样子的，我们都可以对它执行相同的操作。