二十六、算法 -- 插入排序，希尔排序（缩小增量排序），堆排序，归并排序

不写讲解了，直接贴代码了。这里稍微有点难度的就是归并排序了，分治思想的初级体现，一定要仔细研究。

 

1、插入排序

//插入排序,类似于二叉堆的下溯
void InsertSort(int array[], int size)
{
	int i, j;
	for(i = 0; i < size; i++)
	{
		int temp = array[i];
		for(j = i; j > 0 && array[j - 1] > temp; j--)
		{
			array[j] = array[j - 1];
		}
		array[j] = temp;
	}
}

2、希尔排序

//希尔排序,缩小增量排序； Sedgewick : 9 * 4^i - 9 * 2^i + 1 或 4^i - 3 * 2^i + 1 
void ShellSort(int array[], int size)
{
	int i, j, increment;
	int temp;
	for(increment = size / 2; increment > 0; increment /= 2)
	{
		for(i = increment; i < size; i++)
		{
			temp = array[i];
			for(j = i; j >= increment; j -= increment)
			{
				if(temp < array[j - increment])
				{
					array[j] = array[j - increment];
				}
				else
				{
					break;
				}
			}
			array[j] = temp;
		}
	}
}

3、堆排序 

#include <stdio.h>

#define LeftChild(index) index * 2 + 1

//打印数组
void PrintArray(int array[], int size)
{
	for(int i = 0; i < size; i++)
	{
		printf("%d\t", array[i]);
	}
	printf("\n");
}

//交换两个元素
void Swap(int *front, int *rear)
{
	(*front) = (*front) - (*rear);
	(*rear) = (*front) + (*rear);
	(*front) = (*rear) - (*front);
}

//对小值进行下溯
void PercDown(int array[], int i, int size)
{
	int temp, child;
	for(temp = array[i]; LeftChild(i) < size; i = child)
	{
		child = LeftChild(i);
		if(child + 1 < size && array[child] < array[child + 1])
		{
			child++;
		}
		if(temp < array[child])
		{
			array[i] = array[child];
		}
		else
		{
			break;
		}
	}
	array[i] = temp;
}

//堆排序入口
void HeapSort(int array[], int size)
{
	int i;
	for(i = size / 2; i >= 0; i--)
	{
		PercDown(array, i, size);
	}
	for(i = size - 1; i > 0; i--)
	{
		Swap(&array[0], &array[i]);
		PercDown(array, 0, i);
	}
}

int main(void)
{
	int array[] = {34, 8, 64, 51, 32, 31};
	int size = sizeof(array)/sizeof(array[0]);
	HeapSort(array, size);
	PrintArray(array, size);
	return 0;
}

4、归并排序 

#include <stdio.h>

void PrintArray(int array[], int size)
{
	for(int i = 0; i < size; i++)
	{
		printf("%d\t", array[i]);
	}
	printf("\n");
}

//对分治数组进行排序存储到模板数组，并拷贝回去
void Merge(int array[], int tmpArray[], int leftPtr, int centerPtr, int rightPtr)
{
	int leftEnd, rightStart, tmpPtr, numSum;
	leftEnd = centerPtr;
	rightStart = centerPtr + 1;
	tmpPtr = leftPtr;
	numSum = rightPtr - leftPtr + 1;
	while(leftPtr <= leftEnd && rightStart <= rightPtr)
	{
		if(array[leftPtr] < array[rightStart])
		{
			tmpArray[tmpPtr++] = array[leftPtr++];
		}
		else
		{
			tmpArray[tmpPtr++] = array[rightStart++]; 
		}
	}
	while(leftPtr <= leftEnd)
	{
		tmpArray[tmpPtr++] = array[leftPtr++];
	}
	while(rightStart <= rightPtr)
	{
		tmpArray[tmpPtr++] = array[rightStart++];
	}
	for(int i = 0; i < numSum; i++, rightPtr--)
	{
		array[rightPtr] = tmpArray[rightPtr];
	}
}

//递归进行分治处理，由杂化简
void MergeComponent(int array[], int tmpArray[], int leftPtr, int rightPtr)
{
	int centerPtr; //定义中间指针
	if(leftPtr < rightPtr)
	{
		centerPtr = (rightPtr + leftPtr)/2;
		MergeComponent(array, tmpArray, leftPtr, centerPtr); //左分治
		MergeComponent(array, tmpArray, centerPtr+1, rightPtr); //右分治
		Merge(array, tmpArray, leftPtr, centerPtr, rightPtr); 
	}
}

//归并排序入口
void MergeSort(int array[], int size)
{
	int tmpArray[size];
	MergeComponent(array, tmpArray, 0, size - 1);
}

int main(void)
{
	int array[] = {24,13,26,1,2,27,38,15};
	int size = sizeof(array)/sizeof(array[0]);
	MergeSort(array, size);
	PrintArray(array, size);
	return 0;
}