【 日常 】 小排序合集 17年4月12日22:17 [ 10 ]

/*前言： 好多天前准备记录下自己的坎坷修仙的点滴，以后希望能留下【珍贵的回忆】，萌新的日常代码，大佬互喷*/

代码写的比较繁琐，多多见谅，萌新每天都在努力改变自己

心情：不想吐槽啥，恩对，不吐槽啥，每天感觉无所事事，很无聊的样子的，也每天装作很开心的样子，恩。突然想到了一句话：

【如果不能找到一个与你同行的，那么便独自前行。】

# include <stdio.h>
# include <stdlib.h>
# define N 10
void ShellSort(int a[]);
int main(void)
{
	int a[N] = { 10,9,8,7,6,5,4,3,2,1 };
	ShellSort(a);
	for (int i = 0; i < N; ++i)
		printf("%d\t", a[i]);
	system("pause");
	return 0;
}
void ShellSort(int a[])
{
	int i, j, k, gap;
	int temp;
	for (gap = N / 2; gap > 0; gap /= 2)//步长
	{
		for (i = 0; i < gap; ++i)//0-gap组
		{
			for (j = i + gap; j < N; j += gap)//每组开头第二个数，加到gap到最后
			{
				for (k = j - gap, temp = a[j]; k >= 0; k -= gap)//插入
					if (a[k] > temp)
						a[k + gap] = a[k];
					else
						break;
				a[k + gap] = temp;
			}
		}
	}
}

简单的小快排，未使用三点中值，所以不太建议使用，最近没时间，所以我会尽量的快点敲用三点中值法找枢纽元的快排，但是快排的基本思想可以参考

# include <stdio.h>
# include <stdlib.h>
# define N 10
void QuickSort(int a[], int, int);
int main(void)
{
	int a[N] = { 7,10,22,3,8,0,11,4,9,12 };
	QuickSort(a, 0, N - 1);
	for (int i = 0; i < N; ++i)
		printf("%d\t", a[i]);
	system("pause");
	return 0;
}
void QuickSort(int a[], int Frist, int Last)
{
	if (Frist > Last || Frist < 0 || Last >= N)
		return;
	int F, L, mid;
	int temp;
	F = Frist;
	L = Last;
	temp = a[Frist];
	while (Frist < Last)
	{
		while (Frist < Last&&a[Last] > temp)
			Last--;
		a[Frist] = a[Last];
		while (Frist < Last&&a[Frist] < temp)
			Frist++;
		a[Last] = a[Frist];
	}
	a[Frist] = temp;
	mid = Frist;
	QuickSort(a, F, mid - 1);
	QuickSort(a, mid + 1, L);
}

下面是堆排序，首先改变渗透的比较，把原先的最小堆改成最大堆，为了减少存储空间，把最大的放到最后，然后当前个数减少一个，这样就省得花别的空间存储，

排序完成后就是从小到大的排序，如果从大到小，那么就堆改成原先的最小堆就好了，好了不说了，上代码

说下的就是如果你习惯了，不使用0结点存储的话，那么如果 父亲  i 那么 左孩子 2 i 右孩子2 i + 1 

	/*----------------------------------------
			构建大堆，堆排序后从小到大
			算上0 左奇右偶）
			右父【 child/2-1】
			右 【 child 】左【child-1】
	父亲为 i 左孩子为 2 i   右孩子为 2（i+1）
	-------------------------------------------*/
# include <stdio.h>
# include <malloc.h>
# include <stdlib.h>
# define MaxSize 20
struct HeapNode
{
	int *pHeapData;
	int CurrentSize;
	int Capacity;
};
HeapNode* InitHeapNode(HeapNode*);
void AddHeapNum(HeapNode*, int);
void HeapSort(HeapNode*);
void PercolateUp(HeapNode*, int );
void PercolateDown(HeapNode*,int);
void TrevalHeap(HeapNode*);
int main(void)
{
	HeapNode*pHead = NULL;
	pHead = InitHeapNode(pHead);
	AddHeapNum(pHead, 3);
	AddHeapNum(pHead, 2);
	AddHeapNum(pHead, 4);
	AddHeapNum(pHead, 8);
	AddHeapNum(pHead, 1);
	AddHeapNum(pHead, 7);
	AddHeapNum(pHead, 9);
	printf("\n未排序前:\n");
	TrevalHeap(pHead);
	printf("\n排序后：\n");
	HeapSort(pHead);
	TrevalHeap(pHead);
	system("pause");
	return 0;
}
HeapNode* InitHeapNode(HeapNode*pHead)
{
	if (!pHead)
	{
		pHead = (HeapNode*)malloc(sizeof(HeapNode));
		if (!pHead)
		{
			printf("ERROR：Out of Space \n");
			exit(-1);
		}
		pHead->Capacity = MaxSize;
		pHead->CurrentSize = 0;
		pHead->pHeapData = (int*)malloc(sizeof(int)*MaxSize);
		if (!pHead->pHeapData)
		{
			printf("ERROR：Out of Space \n");
			exit(-1);
		}
	}
	return pHead;
}
void AddHeapNum(HeapNode*pHead, int AddNum)
{
	if (!pHead)
		return;
	if (pHead->CurrentSize < pHead->Capacity)
		PercolateUp(pHead, AddNum);
	else
		printf("\nThe Heap is Full \n");
}
void HeapSort(HeapNode*pHead)
{
	if (!pHead)
		return;
	int temp;
	int Sentinel = pHead->CurrentSize;
	while (Sentinel > 0)
	{
		Sentinel--;
		temp = pHead->pHeapData[Sentinel];
		pHead->pHeapData[Sentinel] = pHead->pHeapData[0];
		pHead->pHeapData[0] = temp;
		PercolateDown(pHead,Sentinel);//下渗
	}
}
void PercolateDown(HeapNode*pHead,int CurrentSIZE)
{
	if (!pHead)
		return;
	int temp;
	int Parent = 0;
	int Child = 2 * Parent + 1;//左孩子
	while (Child < CurrentSIZE)//左孩子在范围内
	{
		if ((Child != (CurrentSIZE - 1)) && pHead->pHeapData[Child] < pHead->pHeapData[Child + 1])//存在右且右大左
			Child = Child + 1;	//左右比较找最大
		if (pHead->pHeapData[Parent] < pHead->pHeapData[Child])
		{
			temp = pHead->pHeapData[Parent];
			pHead->pHeapData[Parent] = pHead->pHeapData[Child];
			pHead->pHeapData[Child] = temp;
			Parent = Child;//大的成为父亲，原父亲下渗成为当前的孩子
			Child = 2 * Parent + 1;
		}
		else
			break;
	}
}
void PercolateUp(HeapNode*pHead,int PercolateNum)
{
	if (!pHead)
		return;
	int Child = pHead->CurrentSize;
	int Parent=Child;
	while (Parent >= 0 && pHead->pHeapData[Parent] <= PercolateNum)
	{
		pHead->pHeapData[Child] = pHead->pHeapData[Parent];//父亲下渗
		Child = Parent;
		if (Child % 2 == 0)//偶右
			Parent = (Child / 2) - 1;
		else
			Parent = Child / 2;
	}
	pHead->pHeapData[Child] = PercolateNum;
	pHead->CurrentSize++;
}
void TrevalHeap(HeapNode*pHead)
{
	if (!pHead)
	{
		printf("ERROR：Out of Space \n");
		exit(-1);
	}
	int Sentinel = 0;
	while (Sentinel < pHead->CurrentSize)
	{
		printf("%d\t", pHead->pHeapData[Sentinel]);
		Sentinel++;
	}
	return;
}