插入排序，希尔排序，冒泡排序，快速排序，选择排序，堆排序，c/c++描述

  这些排序方法非常精妙，但各有不同，这里给出代码汇总，至于分析过程，见前几篇文章，和网上资料的优秀讲解。同时也是再写一遍代码，加深印象。代码死记硬背不必要，关键在于理解原理。
先是main函数所在源文件代码：

#include<iostream>
using namespace std;

extern void swap(int & i,int & j);
extern void dispaly(int array[],int length);

extern void directInsertSort(int array[], int indexStart, int indexEnd);
extern void binaryInsertSort(int array[],int length);
extern void shellsort(int array[],int length);

extern void bubbleSortBasic(int array[],int length);
extern void bubbleSortBetter(int array[],int length);
extern void quickSort(int array[], int indexStart,int indexEnd);

extern void selectSort(int array[],int length);
extern void heapSort(int array[], int length);

int main() {
	int a[] = { 5,1,6,3,0,9,8,7,2,4 }, b[] = { 5,1,6,3,0,9,8,7,2,4 },
		c[] = { 5,1,6,3,0,9,8,7,2,4 }, d[] = { 5,1,6,3,0,9,8,7,2,4 },
		e[] = { 5,1,6,3,0,9,8,7,2,4 }, f[] = { 5,1,6,3,0,9,8,7,2,4 },
		g[] = { 5,1,6,3,0,9,8,7,2,4 }, h[] = { 5,1,6,3,0,9,8,7,2,4 };
	int length = 10;

	directInsertSort(a,0,length - 1);
	binaryInsertSort(b,length);
	shellsort(c,length);

	bubbleSortBasic(d,length);
	bubbleSortBetter(e,length);
	quickSort(f,0,length - 1);

	selectSort(g,length);
	heapSort(h,length);

	dispaly(a,length);
	dispaly(b, length);
	dispaly(c, length);
	dispaly(d, length);
	dispaly(e, length); 
	dispaly(f, length);
	dispaly(g, length);
	dispaly(h, length);

	return 0;
}

接着是各函数所在源文件：

#include<iostream>
using namespace std;

void swap(int& i, int& j) {
	int temp = i;
	i = j;
	j = temp;
}
void dispaly(int array[], int length) {
	for (int i = 0; i < length; i++)
		cout << array[i] << ' ';
	cout << endl;
}

void directInsertSort(int array[], int indexStart,int indexEnd) {
	int temp,index,i;

	for (index = indexStart + 1; index <= indexEnd; index++) {
		temp = array[index];
		i = index - 1;

		while (i >= 0 && array[i] > temp) {
			array[i + 1] = array[i];
			i--;
		}
		array[i + 1] = temp;
	}
}

void binaryInsertSort(int array[], int length) {
	int indexStart, indexEnd, indexMid,temp;

	for (int i = 1; i < length; i++) {
		temp = array[i];

		indexStart = 0;
		indexEnd = i - 1;

		while (indexStart <= indexEnd) {
			indexMid = (indexStart + indexEnd) / 2;
			if (array[indexMid] > temp)
				indexEnd = indexMid - 1;
			else
				indexStart = indexMid + 1;
		}
	
		for (int j = i; j > indexStart; j--)
			array[j] = array[j - 1];
		array[indexStart] = temp;
	}
}

void shellsort(int array[], int length) {
	int gap = length / 2,index,temp,j;
	while (gap > 0) {
		for (index = gap; index < length; index++) {
			temp = array[index];
			j = index - gap;

			while (j >= 0 && array[j] > temp) {
				array[j + gap] = array[j];
				j -= gap;
			}

			array[j + gap] = temp;
		}
		gap = gap / 2;
	}
}

void bubbleSortBasic(int array[], int length) {
	for (int i = 0; i < length - 1; i++)
		for (int j = length - 1; j > i; j--)
			if (array[j] < array[j - 1])
				swap(array[j],array[j - 1]);
}

void bubbleSortBetter(int array[], int length) {
	bool sorted = false;
	for (int i = 0; !sorted && i < length - 1; i++) {
		sorted = true;

		for(int j = length - 1; j > i ;j--)
			if (array[j] < array[j - 1]) {
				swap(array[j],array[j - 1]);
				sorted = false;
			}
	}
}

int partition(int array[], int indexStart, int indexEnd) {
	int indexMid = (indexStart + indexEnd) / 2;
	if (array[indexStart] > array[indexEnd])
		swap(array[indexStart],array[indexEnd]);
	if (array[indexMid] > array[indexEnd])
		swap(array[indexMid],array[indexEnd]);
	if (array[indexStart] < array[indexMid])
		swap(array[indexStart],array[indexMid]);

	int temp = array[indexStart];
	while (indexStart < indexEnd) {
		while (indexStart < indexEnd && array[indexEnd] >= temp)
			indexEnd--;
	
		if (indexStart < indexEnd) {
			array[indexStart] = array[indexEnd];
			indexStart++;
		}
	
		while (indexStart < indexEnd && array[indexStart] <= temp)
			indexStart++;
	
		if (indexStart < indexEnd) {
			array[indexEnd] = array[indexStart];
			indexEnd--;
		}
	}

	array[indexStart] = temp;
	return indexStart;
}

void quickSort(int array[], int indexStart, int indexEnd) {
	if (indexEnd - indexStart > 2) {
		int pivotIndex = partition(array,indexStart,indexEnd);
		quickSort(array,indexStart,pivotIndex - 1);
		quickSort(array,pivotIndex + 1,indexEnd);
	}
	else
		directInsertSort(array,indexStart,indexEnd);
}

void selectSort(int array[], int length) {
	int i, indexMin;
	
	for (i = 0; i < length; i++) {
		indexMin = i;
		for (int j = i + 1; j < length; j++)
			if (array[indexMin] > array[j])
				indexMin = j;

		if (i != indexMin)
			swap(array[i],array[indexMin]);
	}
}

void heapAdjust(int array[], int length, int index) {
	int indexMax = index;

	if (index * 2 + 1 < length - 1 && array[index * 2 + 1] > array[index])
		indexMax = index * 2 + 1;
	if (index * 2 + 2 < length - 1 && array[index * 2 + 2] > array[indexMax])
		indexMax = index * 2 + 2;

	if (indexMax != index) {
		swap(array[indexMax], array[index]);
		heapAdjust(array, length, indexMax);
	}
}

void heapSort(int array[], int length) {
	for (int i = (length - 2) / 2; i >= 0; i--)
		heapAdjust(array,length,i);

	for (int i = length - 1; i > 0; i--) {
		swap(array[0],array[i]);
		heapAdjust(array,i,0);
	}
}

接着是测试结果：

各种方法都给出了正确的结果。谢谢阅读
随后学习归并排序等等。