选择排序，冒泡排序，快速排序，Shell排序，归并排序，二分法插入排序，堆化数组，堆排序

排序算法实现。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int print(const int *ar, int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d\t", ar[i]);
	}
	puts("");
	return 0;
}


void swap(int * ar, int i, int j)
{
	int temp;
	temp = ar[i];
	ar[i] = ar[j];
	ar[j] = temp;
}


//---------------排序----------------


//选择排序
int Ch_Sort(int ar[],int length);


//插入排序
int insert_Sort(int *ar, int length);


//冒泡排序
int Bubble_Sort(int *ar, int length);


//快排
int Q_Sort(int *ar, int  len);
int partition(int *ar,int low,int high);
int QSort(int *ar, int low, int high);


//Shell
int Shell_insert(int *ar, int n, int g);
int Shell_Sort(int ar[],int length);


//归并排序
int Merge_Sort(int *,int );
void Merge(int ar[],int des[],int low,int mid,int high);
void M_Sort(int ar[], int des[], int low, int max, int high);


//二分法插入排序
int Bin_Sort(int ar[],int length);


//堆排序(小根堆)
int HeapInsert(int *ar,int n,int num);
void MinHeapFixup(int *ar,int n);
void MinHeapFixdown(int *ar, int n, int i);
void MakeMinHeap(int ar[], int length);
void MinHeapSort(int ar[], int length);


void main()
{
	int ret, len;
	int ar[] = {12,5,433,253,216,7};
	len = sizeof(ar) / sizeof(int);
	print(ar,len);
	MinHeapSort(ar, len);
	//if (ret != 0)
	//{
	//	printf("insert_Sort err %d\n",ret);
	//	exit(1);
	//}
	print(ar, len);
	system("pause");
}




//选择排序
int Ch_Sort(int ar[], int length)
{
	int ret = 0;
	int i, j;
	if (ar == NULL)
	{
		ret = -1;
		return ret;
	}
	for ( i = 0; i < length; i++)
	{
		for ( j = i; j < length; j++)
		{
			if (ar[i] > ar[j])
			{
				swap(ar,i,j);
			}
		}
	}
	return ret;
}


//插入排序
int insert_Sort(int *ar,int length)
{
	int ret = 0;
	int i, j,k,temp;
	if (ar == NULL)
	{
		ret = 1;
		return ret;
	}
	for (i = 1; i < length; i++)
	{
		k = i;
		temp = ar[k];
		for ( j = i - 1; (j >= 0)&&(ar[j] > temp); j--)
		{
			ar[j + 1] = ar[j];
			k = j;
		}
		ar[k] = temp;
	}
	return ret;
}




//冒泡排序
int Bubble_Sort(int *ar, int length)
{
	int temp;
	int ret = 0;
	int i, j;
	if (ar == NULL)
	{
		ret = 1;
		return ret;
	}
	for ( i = 0; i < length; i++)
	{
		for ( j = length - 1; j > i; j--)
		{
			if (ar[j] < ar[j - 1])
			{
				//swap(ar,j,j - 1);
				temp = ar[j];
				ar[j] = ar[j - 1];
				ar[j - 1] = temp;


			}


		}
	}
	return ret;
}




//快速排序
int partition(int *ar, int low, int high)
{
	int temp = ar[low];
	while (low < high)
	{
		while ((low < high)&&(ar[high] >= temp))
		{
			high--;
		}
		swap(ar,low,high);
//		low++;
		while ((low < high) && (ar[low] <= temp))
		{
			low++;
		}
		swap(ar, low, high);
	}
	return low;
}


int QSort(int *ar, int low, int high)
{
	int ret = 0;
	int pivot;
	if (ar == NULL)
	{
		ret = -1;
		return ret;
	}
	if (low < high)
	{
		pivot = partition(ar, low, high);
		QSort(ar, low, pivot - 1);
		QSort(ar, pivot + 1, high);
	}
	return ret;
}


int Q_Sort(int *ar, int  len)
{
	int ret = QSort(ar,0,len - 1);
	return ret;
}




//Shel Sort
int Shell_insert(int *ar, int n, int g)
{
	int ret = 0;
	int i, j;
	int k, temp;
	if (ar == NULL)
	{
		ret = -1;
		return ret;
	}
	for ( i = g; i < n; i++)
	{
		k = i;
		temp = ar[k];
		for ( j = i - g; (j >= 0)&&(ar[j] > temp); j-=g)
		{
			ar[j + g] = ar[j];
			k = j;
		}
		ar[k] = temp;
	}
	return ret;
}


int Shell_Sort(int ar[], int length)
{
	int ret;
	int g = 0;
	if (ar == NULL)
	{
		ret = -1;
		return ret;
	}
	for ( g = length/2; g > 0; g/=2)
	{
		ret = Shell_insert(ar,length,g);
		if (ar == NULL)
		{
			ret = -1;
			return ret;
		}
	}
	return ret;
}




//归并排序
int Merge_Sort(int *ar, int length)
{
	int ret = 0;
	M_Sort(ar,ar,0,length,length - 1);
	return ret;
}


void Merge(int ar[], int des[], int low, int mid, int high)
{
	int i = low, j = mid + 1;
	int k = low;
	while ((i <= mid) &&(j <= high))
	{
		if (ar[i] > ar[j])
		{
			des[k++] = ar[j++];
		}
		else
		{
			des[k++] = ar[i++];
		}
	}
	while (i <= mid)
	{
		des[k++] = ar[i++];
	}
	while (j <= high)
	{
		des[k++] = ar[j++];
	}
}


void M_Sort(int ar[], int des[], int low, int max, int high)
{
	if (low == high)
	{
		des[low] = ar[low];
	}
	else
	{
		int mid = (low + high) / 2;
		int * space = (int *)malloc(sizeof(int) * max);
		memset(space, 0, (sizeof(int) * max));
		if (space != NULL)
		{
			M_Sort(ar, space, low, max, mid);
			M_Sort(ar, space, mid + 1, max, high);
			Merge(space,des,low,mid,high);
		}
		free(space);
	}
}




//二分法插入排序
int Bin_Sort(int ar[], int length)
{
	int left, right, mid, i, j;
	int temp;
	for ( i = 1; i < length; i++)
	{
		left = 0;
		right = i - 1;
		temp = ar[i];
		while (left <= right)
		{
			mid = (left + right) / 2;
			if (ar[mid] > temp)
			{
				right = mid - 1;
			}
			else
			{
				left = mid + 1;
			}
		}
		for ( j = i; j > left; j--)
		{
			ar[j] = ar[j - 1];
		}
		ar[left] = temp;
	}
	return 0;
}




//堆排序(小根堆)
int HeapInsert(int *ar, int n, int num)
{
	int ret = 0;
	if (ar == NULL)
	{
		ret = -1;
		return ret;
	}
	int i, j;
	i = n;
	ar[i] = num;
	j = (i - 1) / 2;
	while ((j >= 0)&&(i != 0))
	{
		if (ar[j] < ar[i])
		{
			ar[i] = ar[j];
			i = j;
			j = (i - 1) / 2;
		}
		else
		{
			break;
		}
	}
	ar[i] = num;
	for (int i = 0; i <= n; i++)
	{
		printf("%d\t", ar[i]);
	}
	puts("");
	return ret;
}


//数组堆化,n为数组长度，i为对i为root的树堆化
void MinHeapFixdown(int *ar, int n, int i)
{//对第一个不是叶子节点的节点堆化
	int j;
	int temp = ar[i];
	j = 2*i + 1;
	while (j < n)
	{
		if ((j + 1 < n)&&(ar[j + 1] < ar[j]))
		{
			j++;
		}
		if (ar[j] >= temp)
		{
			break;
		}
		ar[i] = ar[j];
		i = j;
		j = 2 * i + 1;
	}
	ar[i] = temp;
}


//循环至根节点，依次进行堆化
void MakeMinHeap(int ar[], int length)
{
	int i;
	for ( i = (length - 1) / 2; i >=0; i--)
	{
		MinHeapFixdown(ar,length,i);
	}
}
void MinHeapFixup(int *ar, int n)
{
	int j, temp;
	temp = ar[n];
	j= (n - 1) / 2;
	while ((j >= 0) && (n != 0))
	{
		if (ar[j] <= temp)
		{
			break;
		}
		ar[n] = ar[j];
		n = j;
		j = (n - 1) / 2;
	}
	ar[n] = temp;
}


//堆排序
//首先叶子节点均可视为已堆化，然后叶子节点的父节点视为堆的插入操作。
//构建完小根堆后，以此将root与最后一个叶子进行交换，每次交换完，均视为执行一次堆的插入；
//堆逐渐减少，直至仅有一个元素时，堆排序完毕。

//如ar[0]为最小，其先与ar[n - 1]交换，此时，n位置为最小元素，小根堆内数据减少一个;
//第二次将ar[0]与ar[n – 2]交换，再对A[0…n - 3]重新恢复堆，重复这样的操作直到A[0]与A[1]交换。
//由于每次都是将最小的数据并入到后面的有序区间，故操作完成后整个数组就有序。
void MinHeapSort(int ar[],int length)
{
	MakeMinHeap(ar, length);
	for (int i = length - 1; i >=  1; i--)
	{
		swap(ar, 0, i);
		MakeMinHeap(ar, i);
	}
}