C语言-----六种排序（选择排序、插入排序、冒泡排序、希尔排序、快速排序、归并排序）

选择排序

#include "stdio.h"
#include "stdlib.h"
#include "string.h"

void printArray01(int array[], int len)
{
	int i = 0;
	for(i=0; i

插入排序

#include "stdio.h"
#include "stdlib.h"
#include "string.h"

void printArray02(int array[], int len)
{
	int i = 0;

	for(i=0; i=0) && (array[j]>temp); j--)
		{ 
			array[j+1] = array[j]; //元素后移
			k = j; //k需要插入的位置
		}

		array[k] = temp;//元素插入
	}
}

int main()
{
	int array[] = {12, 5, 433, 253, 216, 7};
	int len = sizeof(array) / sizeof(*array); 

	printArray02(array, len);
	InertionSort(array, len);
	printArray02(array, len);
	system("pause");
	return 0;
}

冒泡排序

#include "stdio.h"
#include "stdlib.h"
#include "string.h"

void printfArray03(int array[], int len)
{
	int i = 0;

	for(i=0; ii; j--)
		{
			if( array[j] < array[j-1] )
			{
				swap03(array, j, j-1);
				exchange = 1;//
			}
		}
	}
}

int main()
{
	int array[] ={8,3,6,1};
	int len = sizeof(array) / sizeof(*array); 
	printfArray03(array, len);
	BubbleSort(array, len);
	printfArray03(array, len);
	system("pause");
	return 0;
}

希尔排序

#include "stdio.h"
#include "stdlib.h"
#include "string.h"

void println(int array[], int len)
{
	int i = 0;

	for(i=0; i=0) && (array[j]>temp); j--)
		{ 
			array[j+1] = array[j]; //元素后移
			k = j; //k需要插入的位置
		}

		array[k] = temp;//元素插入
	}
}

//nlogn
void ShellSort(int array[], int len) //
{
	int i = 0;
	int j = 0;
	int k = -1;
	int temp = -1;
	int gap = len;
	do
	{
		 //业界统一实验的 平均最好情况 经过若干次后，收敛为1
		gap = gap / 3 + 1; //gap /2345 2000 都行  //O（n 1.3）
	
		for(i=gap; i=0) && (array[j]>temp); j-=gap)
			{
				array[j+gap] = array[j];
				k = j;
			}

			array[k] = temp;
		}

	}while( gap > 1 );

}


int main()
{
	int array[] = {12, 5, 433, 253, 216, 7};
	int len = sizeof(array) / sizeof(*array); 

	println(array, len);
	ShellSort(array, len);
	println(array, len); 
	system("pause");
	return 0;
}

快速排序

void printArray05(int array[], int len)
{
	int i = 0;

	for(i=0; i= pv) )
		{
			high--; //比基准大，本来就在右边，所以high前移动
		}
		swap5(array, low, high);
		while( (low < high) && (array[low] <= pv) )
		{
			low++;
		}
		swap5(array, low, high);
	}
	//返回枢轴的位置。。。重要
	return low;
}

//让n个元素 依此减少 减少到1个元素的时候，因为1个元素可以看成一个有序的序列

void QSort2(int array[], int low, int high)
{
	if( low < high )
	{
		int pivot = partition(array, low, high);
		
		//对子序列1排序
		QSort2(array, low, pivot-1);
		//对子序列2排序
		QSort2(array, pivot+1, high);
	}
}

void QSort(int array[], int low, int high)
{
	if( low < high )
	{
		int pivot = partition(array, low, high);

		//对子序列1排序
		QSort2(array, low, pivot-1);
		//对子序列2排序
		QSort2(array, pivot+1, high);
	}
}

void QuickSort(int array[], int len) // O(n*logn)
{
	QSort(array, 0, len-1);
}

int main()
{
	//int array[] = {12, 5, 433, 253, 216, 7};
	//int array[] = {12, 5, 433};
	int array[] = {12, 5};
	int len = sizeof(array) / sizeof(*array); 
	printArray05(array, len);
	QuickSort(array, len);
	printArray05(array, len);
	system("pause");
	return 0;
}

归并排序

#include 
#include 

void printArray06(int array[], int len)
{
	int i = 0;
	for(i=0; i

结束！