排序算法的代码整理

代码使用vs2010编写，并编译运行成功，参考资料：《数据结构(C语言)》

目前只有：直接插入排序、希尔排序、冒泡排序、快速排序

这里只有代码，分析可以参照博文：排序算法的学习笔记

以下为代码：

SortTest1.h

#include <iostream>

void InsertSort(int L[], int Lsize){
	//直接插入排序O(n^2)
	//L[0]为哨兵，不包含在序列中
	for(int i=2;i <= Lsize; ++i){
		//i=2;从序列的第二个数开始
		if(L[i] < L[i-1]){
			//找到不满足升序的一个数
			L[0] = L[i];     //将该数保存下来
			L[i] = L[i-1];   //将前一个数向后移动一位【这个操作可以忽略，此时j=i-1;】
			int j=i-2;       //上述操作已经将i的前一位后移，所以从i的前第2位开始
			for(;L[0]<L[j]; --j){
				//从j开始，找到i大于那个数为止，也就是找到插入的位置
				//后移所有数
				L[j+1] = L[j];
			}
			//j+1的位置为要插入的位置
			L[j+1] = L[0];
		}
	}
}

void ShellInsert(int L[], int Lsize, int dk){
	//一次希尔排序
	//与上面的直接插入排序做比较，前后记录增量是dk，而不是1；L[0]知识暂存单元
	int i = dk+1;//不再是从第二个数开始，而是从相对于当前增量的第二个数开始
	for(; i<=Lsize; ++i){
		//往后遍历，是 ++i 而不是 i+=dk，因为要遍历整个序列
		if(L[i] < L[i-dk]){
			//相对于当前增量，与前一个数比较
			L[0] = L[i]; //暂时保存
			int j = i - dk; //j不再是i-1，原因在增量
			for(; (j > 0) && (L[0] < L[j]); j-=dk){
				//j-=dk；原因在增量。当j小于0时，插入位置已经找到
				//记录后移，增量的影响
				L[j+dk] = L[j];
			}
			//位置则是j+dk
			L[j+dk] = L[0];
		}
	}
}
void ShellSort(int L[],int Lsize){
	//根据增量序列，调用排序
	//希尔排序，最坏的情况O(n^1.3)
	int dlta[4] = {7,5,3,1};
	for(int k=0; k < 4; ++k){
		ShellInsert(L,Lsize,dlta[k]);
	}
}

void BubbleSort(int L[],int Lsize){
	//冒泡排序，最坏O(n^2),最好O(n)【最好很难出现】
	bool exChange = true;
	//如果没有发生交换，那么便可以停止遍历了
	for(int t = 1; exChange && t<=Lsize;t++){
		//t可以看作做是第t次冒泡，第t次冒泡的最小值放在第t位
		exChange = false;
		for(int i=Lsize; i>=t; --i){
			//每次都从序列的最后开始，一直到每次的顶部
			if(L[i] < L[i-1]){
				//发生交换
				exChange = true;
				//每次都上升较小的值
				L[0] = L[i];
				L[i] = L[i-1];
				L[i-1] = L[0];
			}
		}
	}
}

int Partition(int L[], int low, int high){
	//快速排序的某一次
	int pKey = L[low];//以子序列的low位置为标准
	while(low < high){
		//如果low=high,则表示找到了pKey的位置
		while(low<high && L[high] >= pKey)        //确保low<high,且high的位置都应该不小于pKey
			high--;                               //high前移，直到找到不大于pKey的位置
		L[0] = L[high];                           //将找到的位置与low交换，
		L[high] = L[low];
		L[low] = L[0];
		while(low<high && L[low] <= pKey)         //然后从low开始找，确保low<high,且low的位置都应该不大于pKey
			low++;                                //low后移，直到找到不小于pKey的位置
		L[0] = L[high];                           //同上交换
		L[high] = L[low];
		L[low] = L[0];
	}
	//low与high相等，都为找到的pKey的位置
	return low;
}
void QSort(int L[], int low, int high){
	//快速排序的递归部分
	if(low < high){
		//满足low<high前提下
		//找到low【即pKey】的位置
		int pLoc = Partition(L,low,high);
		//然后根据这个位置，将子序列分成两段去排序
		//子序列    low …… high
		//两段      low … ploc … high
		QSort(L,low,pLoc - 1);
		QSort(L,pLoc + 1,high);
	}
}
void QuickSort(int L[],int Lsize){
	//快速排序，目前被认为是最好的一种内部排序方法
	//O(nlogn)
	QSort(L,1,Lsize);
}

main.cpp

#include <iostream>
#include "SortTest1.h"


int a[9] = {0,49,38,65,97,76,13,27,49};
int sizeOfa = 8;


void PrintArray(){
	std::cout << "数组为：";
	for(int a_i=1; a_i <= sizeOfa; a_i++){
		std::cout << a[a_i] << " ";
	}
	std::cout << std::endl;

}

void sortArray(){
	//InsertSort(a,sizeOfa);//直接插入排序
	//ShellSort(a,sizeOfa);//希尔排序
	//BubbleSort(a,sizeOfa);//冒泡排序
	QuickSort(a,sizeOfa);//快速排序



	PrintArray();
}

int main(){
	sortArray();
	return 0;
}