排序

请原谅我，上来就是在大家眼中水的1B的冒泡排序

可是我相信冒泡排序也是大家看到算法--排序这个大家庭的第一朵鲜花了

 冒泡排序

/*冒泡排序法 容易实现，但是要进行所有轮的比较，运行速度较慢*/
#include<iostream>
using namespace std;
void bubble(int*,int);
void main(){
	int array[]={5,4,6,8,9,3,1,2,7};
	const int len=sizeof(array)/sizeof(int);
	for(int i=0;i<len;++i)
		cout<<array[i]<<" ";
	cout<<endl;
	bubble(array,len);
}
void bubble(int*a,int size){//数组名会自动转化为指向第一个元素的指针，虽然不能直接传递数组，但函数的形参可以写成数组的形式（int*，int[]，int[10]）形参类型都是int*
	int i,temp;
	for(int pass=1;pass<size;++pass){
		for(i=0;i<size-pass;++i)
			if(a[i]>a[i+1]){
				temp=a[i];
				a[i]=a[i+1];
				a[i+1]=temp;
			}
		for(i=0;i<size;++i)
			cout<<a[i]<<" ";
		cout<<endl;
	}
}

快速排序

快速排序可谓是排序大家族中的姣姣者

#include<iostream>
#include<vector>
using namespace std;
int pivotIndex(vector<int>&v, int first, int last)
{
	// index for the midpoint of [first,last) and the
	// indices that scan the index range in tandem
	int mid, scanUp, scanDown;
	// pivot value and object used for exchanges
	int pivot, temp;

	if (first == last)
		return last;
	else if (first == last-1)
		return first;
	else
	{
		mid = (last + first)/2;
		pivot = v[mid];

		// exchange the pivot and the low end of the range
		// and initialize the indices scanUp and scanDown.
		v[mid] = v[first];
		v[first] = pivot;

		scanUp = first + 1;
		scanDown = last - 1;

		// manage the indices to locate elements that are in
		// the wrong sublist; stop when scanDown <= scanUp
		for(;;)
		{
			// move up lower sublist; stop when scanUp enters
			// upper sublist or identifies an element >= pivot
			while (scanUp <= scanDown && v[scanUp] < pivot)
				scanUp++;

			// scan down upper sublist; stop when scanDown locates
			// an element <= pivot; we guarantee we stop at arr[first]
			while (pivot < v[scanDown])
				scanDown--;

			// if indices are not in their sublists, partition complete
			if (scanUp >= scanDown)
				break;

			// indices are still in their sublists and identify
			// two elements in wrong sublists. exchange
			temp = v[scanUp];
			v[scanUp] = v[scanDown];
			v[scanDown] = temp;

			scanUp++;
			scanDown--;
		}

		// copy pivot to index (scanDown) that partitions sublists
		// and return scanDown
		v[first] = v[scanDown];
		v[scanDown] = pivot;
		return scanDown;
	}
}

void quicksort(vector<int>& v, int first, int last)
{
   // index of the pivot
   int pivotLoc;
	// temp used for an exchange when [first,last) has
	// two elements
	int temp;

   // if the range is not at least two elements, return
   if (last - first <= 1)
		return;

	// if sublist has two elements, compare v[first] and
	// v[last-1] and exchange if necessary
   else if (last - first == 2)
	{
		if (v[last-1] < v[first])
		{
			temp = v[last-1];
			v[last-1] = v[first];
			v[first] = temp;
		}
		return;
	}
   else
	{
		pivotLoc = pivotIndex(v, first, last);

		// make the recursive call
		quicksort(v, first, pivotLoc);

		// make the recursive call
		quicksort(v, pivotLoc +1, last);
	}
}
int main()
{
	vector<int>ivec;
	int array[]={2,4,5,6,78,88,34,32,43,24,23,43,24,23,4,23,484};
	int length=sizeof(array)/sizeof(int);
	for(int i =0 ;i<length;++i)
		ivec.push_back(array[i]);
	quicksort(ivec,0,length);
	for(i =0 ;i<length;++i)
		cout<<ivec[i]<<" ";
}

基数排序

想象第一次知道的不基于比较的排序，我记得我当时就直接“震惊了”

#include<iostream>
#include<queue>
#include<vector>
#include "time.h";
using namespace std;
void distribute(const vector<int>& v, queue<int> digitQueue[],
                int power)
{
	int i;

	// loop through the vector, inserting each element into
	// the queue (v[i] / power) % 10
	for (i = 0; i < v.size(); i++)
		digitQueue[(v[i] / power) % 10].push(v[i]);
}

// support function for radixSort()
// gather elements from the queues and copy back to the vector
void collect(queue<int> digitQueue[], vector<int>& v)
{
	int i = 0, digit;

	// scan the vector of queues using indices 0, 1, 2, etc.
	for (digit = 0; digit < 10; digit++)
		// collect items until queue empty and copy items back
		// to the vector
		while (!digitQueue[digit].empty())
		{
			v[i] = digitQueue[digit].front();
			digitQueue[digit].pop();
			i++;
		}
}

void radixSort(vector<int>& v, int d)
{
	int i;
	int power = 1;
	queue<int> digitQueue[10];

	for (i=0;i < d;i++)
	{
		distribute(v, digitQueue, power);
		collect(digitQueue, v);
		power *= 10;
	}
}
void main(){

	vector<int>ivec;
	int i;
	srand(time(NULL));
	for(i=0;i<20;++i)
	{
		ivec.push_back(rand()%20);
	}
	radixSort(ivec,2);

	for(i=0; i<ivec.size();++i){
		cout<<ivec[i]<<" ";
		if((i+1)%5==0)
			cout<<endl;
	}
	cout<<endl;

	
}

归并排序

 

#include<iostream>
#include<vector>
using namespace std;
template <typename T>
void merge(vector<T>& v, int first, int mid, int last)
{
	// temporary vector to merge the sorted sublists
	vector<T> tempVector;
	int indexA, indexB, indexV;

	// set indexA to scan sublistA (index range [first,mid)
	// and indexB to scan sublistB (index range [mid, last)
	indexA = first;
	indexB = mid;

	// while both sublists are not exhausted, compare v[indexA] and
	// v[indexB]copy the smaller to vector temp using push_back()
	while (indexA < mid && indexB < last)
		if (v[indexA] < v[indexB])
		{
			tempVector.push_back(v[indexA]);	// copy element to temp
			indexA++;								// increment indexA
		}
		else
		{
			tempVector.push_back(v[indexB]);	// copy element to temp
			indexB++;								// increment indexB
		}

	// copy the tail of the sublist that is not exhausted
	while (indexA < mid)
	{
		tempVector.push_back(v[indexA]);
		indexA++;
	}

	while (indexB < last)
	{
		tempVector.push_back(v[indexB]);
		indexB++;
	}

	// copy vector tempVector using indexV to vector v using indexA
	// which is initially set to first
	indexA = first;

	// copy elements from temporary vector to original list
	for (indexV = 0; indexV < tempVector.size(); indexV++)
	{
		v[indexA] = tempVector [indexV];
		indexA++;
	}
}

// sorts v in the index range [first,last) by merging
// ordered sublists
template <typename T>
void mergeSort(vector<T>& v, int first, int last)
{
	// if the sublist has more than 1 element continue
	if (first + 1 < last)
  {
		// for sublists of size 2 or more, call mergeSort()
		// for the left and right sublists and then
		// merge the sorted sublists using merge()
		int midpt = (last + first) / 2;

		mergeSort(v, first, midpt);
		mergeSort(v, midpt, last);
		merge(v, first, midpt, last);
   }
}

int main()
{
	vector<int> ivec;
	int array[]={1,2,3,4,5,8,9,7,1,5,2,54,544,54,45,4,5,4,454,45,45,44,54,4,34,2,256,34,926};
	int length=sizeof(array)/sizeof(int);
	for(int i=0;i<length;++i)
	{
		ivec.push_back(array[i]);
	}
	mergeSort(ivec,0,length);

	for(i=0;i<length;++i)
	{
		cout<<ivec[i]<<" ";
	}
	return 0;
}

 

鸽巢排序（来自C++版块精华帖）

排序字节串、宽字节串最快的排序算法，计数排序的变种（将计数缓冲区大小固定，少一次遍历开销），速度是STL中std::sort的20多倍，更重要的是实现极其简单！缺点是需要一个size至少等于待排序数组取值范围的缓冲区，不适合int等大范围数据

#include<iostream>
#include"time.h"
using namespace std;
//鸽巢排序
void PigeonholeSort(int *array,int length)
{

	int b[256]={0};
	int i,j,k;
	for(i=0;i<length;i++)
		b[array[i]]++;
	for(i=0,j=0;i<256;i++)
		for(k=0;k<b[i];k++)
			array[j++]=i;
}
void main()
{	
/*	time_t nowtime;
	nowtime=time(NULL);
	cout<<nowtime;*/
	int array[]={2,5,6,4,1,9,8,7};
	int length=sizeof(array)/sizeof(int);
	PigeonholeSort(array,length);

	for(int m=0; m !=length; ++m)
		cout<<array[m]<<" ";
}

 

 先附上好东西一个

冒泡和选择排序该被踢出教材了

这是C++版块关于排序的一个精华帖，很不错的的说

 

今天写不完了，明天继续。

 

我的新浪微博是@酥西黄

我的邮箱是suziewong@163.com