排序算法(待更新)

1、Bubbling sort

#include <iostream>
#include <ctime>

using namespace std;

void bubbleSort(int iarray[], int n)
{
	bool flag = false;
	for(int i=0; i<n-1&&!flag; ++i)
	{
		for(int j=i+1; j<n; ++j)
		{
			if(iarray[i]>iarray[j])
			{
				int tmp = iarray[i];
				iarray[i] = iarray[j];
				iarray[j] = tmp;
			}
		}
	}
}

int main()
{
	int iarray[10];
	srand(time(NULL));
	for(int i=0; i<10; ++i)
	{
		iarray[i] = rand()%100;
		cout << iarray[i] << " ";
	}
	cout << endl;

	bubbleSort(iarray, 10);

	for(int i=0; i<10; ++i)
	{
		cout << iarray[i] << " ";
	}
	cout << endl;

	system("pause");
	return 0;
}

2、quick sort

#include <iostream>
#include <ctime>

using namespace std;

const int ARRAY_LEN = 100;
int iarray[ARRAY_LEN];

int divide(int low, int high)
{
	if(low>=high)return -1;

	int pvoit = iarray[low];
	while (low<high)
	{
		while (iarray[high]>=pvoit&&low<high)
		{
			high--;
		}
		if(low<high)
		{
			iarray[low] = iarray[high];
			low++;
		}
		while (iarray[low]<=pvoit&&low<high)
		{
			low++;
		}
		if(low<high)
		{
			iarray[high] = iarray[low];
			high--;
		}
	}

	iarray[low] = pvoit;

	return low;
}

void myQsort(int low, int high)
{
	int mid = divide(low, high);
	if(mid!=-1)
	{
		myQsort(low, mid-1);
		myQsort(mid+1, high);
	}
}

int main()
{
	srand(time(NULL));

	for(int i=0; i<20; ++i)
	{
		iarray[i] = rand()%100;
		cout << iarray[i] << " ";
	}
	cout << endl;
	myQsort(0, 19);

	for(int i=0; i<20; ++i)
	{
		cout << iarray[i] << " ";
	}
	cout << endl;

	system("pause");
	return 0;
}

3、HeapSort

//第一步：建立大顶堆，从最后一个非叶子节点按照从右到左从下到上的顺序逐步调整当前子树为大顶堆直到根节点
//第二步：移除大顶推的顶部最大元素，同时把最后一个叶节点移到根的位置，此时大顶堆可能遭到破坏需要调整
//第三步：从堆得顶部（根节点）向下调整堆使得每棵子树也符合大顶堆的要求
//第三步：重复二三步骤直到仅剩一个元素排序完成
#include <iostream>

using namespace std;

void HeapAdjust(int array[], int cur, int size)//从上向下调整
{
	int lchild = 2*cur;
	int rchild = 2*cur+1;

	int maxIndex = cur;
	if(lchild<=size&&array[lchild]>array[maxIndex])
	{
		maxIndex = lchild;
	}
	if(rchild<=size&&array[rchild]>array[maxIndex])
	{
		maxIndex = rchild;
	}

	if(cur!=maxIndex)
	{
		swap(array[cur], array[maxIndex]);
		HeapAdjust(array, maxIndex, size);
	}
}

void BuildMaxHeap(int array[], int size)//从下向上调整
{
	for(int i=size/2; i>0; --i)
	{
		HeapAdjust(array, i, size);
	}
}

void HeapSort(int array[], int size)
{
	BuildMaxHeap(array, size);
	for(int i=size; i>1; --i)
	{
		swap(array[i], array[1]);
		HeapAdjust(array, 1, i-1);
	}
}

int main()
{
	int array[]={0,6,2,8,10,24,12,46,74,23};
	int size = 9;

	HeapSort(array, size);

	for(int i=1; i<=size; ++i)
	{
		cout << array[i] << " ";
	}
	cout << endl;

	system("pause");
	return 0;
}

堆排序应用：优先队列（最大优先队列用于作业调度，最小优先队列用于基于事件驱动的模拟器（以时间为关键字））

最大优先队列代码示例：

#include <iostream>

using namespace std;

void HeapAdjust(int array[], int cur, int size)//从上向下调整
{
	int lchild = 2*cur;
	int rchild = 2*cur+1;

	int maxIndex = cur;
	if(lchild<=size&&array[lchild]>array[maxIndex])
	{
		maxIndex = lchild;
	}
	if(rchild<=size&&array[rchild]>array[maxIndex])
	{
		maxIndex = rchild;
	}

	if(cur!=maxIndex)
	{
		swap(array[cur], array[maxIndex]);
		HeapAdjust(array, maxIndex, size);
	}
}

void BuildMaxHeap(int array[], int& size)//从下向上调整
{
	for(int i=size/2; i>0; --i)
	{
		HeapAdjust(array, i, size);
	}
}

int HeapMaximum(int array[])//获取队列最大值
{
	return array[1];
}

int HeapExtractMax(int array[], int& size)//从队列中取出最大值
{
	if(size<1)
		return -1;

	int maxVal = array[1];

	array[1] = array[size];
	size -= 1;
	HeapAdjust(array, 1, size);
   
	return maxVal;
}

void HeapIncreaseKey(int array[], int i, int key)//增加队列中某一元素的值
{
	if(key<array[i])
	{
		return;
	}
	array[i] = key;

	while(i>1 && array[i/2]<array[i])
	{
		swap(array[i/2], array[i]);
		i /= 2;
	}
}

void HeapInsert(int array[], int key, int& size)//向队列中插入一个值
{
	size += 1;
	array[size] = -1;
	HeapIncreaseKey(array, size, key);
}

int main()
{
	int array[100]={0,6,2,8,10,24,12,46,74,23};
	int size = 9;

	//第一步建立大顶堆
	BuildMaxHeap(array, size);
 
	//第二步最大优先队列
	cout << HeapMaximum(array) << endl;
	cout << HeapExtractMax(array, size) << endl;
	HeapInsert(array, 100, size);
	cout << HeapMaximum(array) << endl;

	system("pause");
	return 0;
}

4、CountSort(计数排序)

//计数排序：对一定范围内的数排序
//把A中的无序数排序后放在B中（下标从1开始，A中数的范围为0—100）
//C[i]记录A 中<=i的数有多少个，也即对应着A中的i值在B中的位置应该是C[i]处
#include <iostream>

using namespace std;

const int LEN = 100;

int main()
{
	int A[LEN+1] = {-1,1,6,4,8,10,20,12,12,78,45};
	int B[LEN+1];
	int C[LEN+1];
	int size = 10;

	memset(C, 0, sizeof(C));
	for(int i=1; i<=size; ++i)
	{
		C[A[i]]++;
	}
	for(int i=1; i<=LEN; ++i)
	{
		C[i] += C[i-1];
	}
	for(int j=size; j>=1; --j)
	{
		B[C[A[j]]] = A[j];
		C[A[j]]--;           //可能有重复值向前移一位
	}

	for(int i=1; i<=size; ++i)
	{
		cout << B[i] << " ";
	}
	cout << endl;

	system("pause");
	return 0;
}

5、MergeSort(归并排序)

2-路归并排序递归实现 
时间复杂度O(nlgn), 辅助空间O(n) 

#include <iostream>

using namespace std;

void Merge(int tmp[], int res[], int l, int mid, int r)
{
	int i, j, k;
	for(i=l, j=mid+1, k=l; i<=mid&&j<=r;++k)
	{
		if(res[i]<res[j])
		{
			tmp[k] = res[i++];
		}
		else
		{
			tmp[k] = res[j++];
		}
	}
	while(i<=mid)tmp[k++] = res[i++];
	while(j<=r)tmp[k++] = res[j++];

	for(i=l;i<=r; ++i)
	{
		res[i] = tmp[i];
	}
}

void MergeSort(int iarray[], int tmp[], int l, int r)
{
	if(l<r)
	{
		int mid = (l+r)/2;
		MergeSort(iarray, tmp, l, mid);
		MergeSort(iarray, tmp, mid+1, r);

		Merge(tmp, iarray, l, mid, r);
	}
}

int main()
{
	int iarray[10] = {9,8,7,6,5,4,3,2,1,0};
	int tmp[10];
	MergeSort(iarray, tmp, 0, 9);

	for(int i=0; i<10; ++i)
	{
		cout << iarray[i] << " ";
	}
	cout << endl;

	//system("pause");
	return 0;
}

2-路归并排序非递归实现 
时间复杂度O(nlgn), 辅助空间O(n) 

#include <iostream>

using namespace std;

void Merge(int tmp[], int res[], int l, int mid, int r)
{
	int i, j, k;
	for(i=l, j=mid, k=l; i<mid&&j<r;++k)
	{
		if(res[i]<res[j])
		{
			tmp[k] = res[i++];
		}
		else
		{
			tmp[k] = res[j++];
		}
	}
	while(i<mid)tmp[k++] = res[i++];
	while(j<r)tmp[k++] = res[j++];

	for(i=l;i<r; ++i)
	{
		res[i] = tmp[i];
	}
}

int main()
{
	int iarray[10] = {9,8,7,6,5,4,3,2,1,0};
	int tmp[10];
	int num = 10;
	int len = 1;
	
	while(len<num)
	{
		int i=0;
		for(; i+2*len<num; i += 2*len)
		{
			Merge(tmp, iarray, i, i+len, i+2*len);
		}
		if(i+len<num)
		{
			Merge(tmp, iarray, i, i+len, num);
		}
		
		len *= 2;
	}

	for(int i=0; i<10; ++i)
	{
		cout << iarray[i] << " ";
	}
	cout << endl;

	//system("pause");
	return 0;
}

6、RadixSort(基数排序)

基数排序：是多关键字排序，比如先按比较第一个关键字再比较第二个关键字.....
以十进制数为例，十进制每个位上的取值范围为0-9，因此基数为10，我们建立是个链表，先比较个位把个位相同的一次放到相应的链表中（有序），这是一次分配；然后收集从第0个链表到第9个链表依次头接尾连接起来，这是第一趟排序，然后使用这种方法对十位，百位...依次操作最后得到的就是有序序列，以三位数字为例如图：

以下代码没有使用List而是用计数的方法使用数组模拟List。

//基数排序：是多关键字排序，比如先按比较第一个关键字再比较第二个关键字.....
//以十进制数为例，十进制每个位上的取值范围为0-9，因此基数为10，我们建立是个链表，先比较
//个位把个位相同的一次放到相应的链表中（有序），这是一次分配；然后收集从第0个链表到第9个链表
//依次头接尾连接起来，这是第一趟排序，然后使用这种方法对十位，百位...依次操作
//最后得到的就是有序序列
//以下代码没有使用List而是用计数的方法使用数组模拟List。
#include <iostream>

using namespace std;

const int  RADIX_10  = 10;   //基数
const int  KEYNUM_31 = 3;    //关键字个数(此处为数字有多少位)

int GetNumInPos(int num,int pos)
{
	int temp = 1;
	for (int i = 0; i < pos - 1; i++)
		temp *= 10;

	return (num / temp) % 10;
}

void RadixSort(int* pDataArray, int iDataNum)
{
	int *auxiliarySpace[RADIX_10];    //分别为0-9的序列空间
	for (int i = 0; i < 10; i++)
	{
		auxiliarySpace[i] = (int *)malloc(sizeof(int) * (iDataNum + 1));
		auxiliarySpace[i][0] = 0;    //index为0处记录这组数据的个数(严蔚民《数据结构》中使用的的链表实现)
	}

	for (int pos = 1; pos <= KEYNUM_31; pos++)    //从个位开始到最高位(也即从第一个关键字到最后一个关键字)
	{
		for (int i = 0; i < iDataNum; i++)    //分配过程
		{
			int num = GetNumInPos(pDataArray[i], pos);
			int index = ++auxiliarySpace[num][0];
			auxiliarySpace[num][index] = pDataArray[i];
		}

		for (int i = 0, j =0; i < RADIX_10; i++)    //收集
		{
			for (int k = 1; k <= auxiliarySpace[i][0]; k++)
				pDataArray[j++] = auxiliarySpace[i][k];
			auxiliarySpace[i][0] = 0;    
		}
	}
}

int main()
{
	int iarray[] = {521,310,72,373,15,546,385,856,187,147};
	RadixSort(iarray, 10);
	for(int i=0; i < sizeof(iarray)/sizeof(iarray[0]); ++i)
	{
		cout << iarray[i] << " ";
	}
	cout << endl;
	system("pause");
	return 0;
}

注：待更新分析总结