八种排序算法

#include<ostream>
using namespace std;

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<assert.h>
#include<time.h>
#include<math.h>
#include<queue>
#include<stack>


void swap(int *a,int *b)
{
	int tmp;
	tmp=*a;
	*a=*b;
	*b=tmp;
}
void show(int *arr,int len)
{
	for(int i=0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n");
}

冒泡排序

时间O（n*n） 空间O（1） 稳定

void BubbleSort(int *ar,int len)
{
	if(NULL==ar || len < 1)
	{
		return ;
	}

	for(int i=0;i<len-1;i++)
	{
		for(int j=0;j<len-i-1;j++)
		{
			if(ar[j]>ar[j+1])
			{
				swap(&ar[j],&ar[j+1]);
			}
		}
	}
}

选择排序

时间O（n*n） 空间O（1） 不稳定

void Selectsort(int *ar,int len)
{
	if(NULL==ar || len <1)
	{
		return ;
	}

	int min;
	int j;
	for(int i=0;i<len;i++)
	{
		min=i;
		for(j=i;j<len;j++)
		{
			if(ar[j]<ar[min])
			{
				min=j;
			}
		}
		swap(&ar[i],&ar[min]);
	}
}

插入排序

时间O（n*n）且数组越有序越趋向于O（n） 空间0（1） 稳定

void InsertSort(int *ar,int len)
{
	if(NULL == ar || len < 1)
	{
		return ;
	}
	int tmp;
	int j;
	for(int i=1;i<len;i++)
	{
		tmp=ar[i];
		for(j=i-1;j>=0;j--)
		{
			if(ar[j]<tmp)
			{
				break;
			}
			ar[j+1]=ar[j];
		}
		ar[j+1]=tmp;
	}
}

希尔排序shell

时间O（1.3~1.5） 空间O（1） 不稳定

void shell(int *ar,int len,int width)
{
	int tmp;
	int j;
	for(int i=width;i<len;i++)
	{
		tmp=ar[i];
		for(j=i-width;j>=0;j-=width)
		{
			if(ar[j]<tmp)
			{
				break;
			}
			ar[j+width]=ar[j];
		}
		ar[j+width]=tmp;
	}
}
void shellsort(int *ar,int len)
{
	if(NULL==ar || len <1)
	{
		return ;
	}
	int tar[]={3,1};
	for(int i=0;i<sizeof(tar)/sizeof(tar[0]);i++)
	{
		shell(ar,len,tar[i]);
	}
}

堆排序

时间O（nlogn） 空间O（1） 不稳定

void Adjust(int *ar,int start,int end)
{
	int tmp=ar[start];
	for(int i=start*2+1;i<=end;i=i*2+1)
	{
		if(i<end && ar[i]<ar[i+1])
		{
			i+=1;
		}
		if(ar[i]<tmp)
		{
			break;
		}
		ar[start]=ar[i];
		start=i;
	}
	ar[start]=tmp;
}
void Heapsort(int *ar,int len)
{
	if(NULL==ar || len<1)
	{
		return ;
	}

	for(int i=(len-2)/2;i>=0;i--)
	{
		Adjust(ar,i,len-1);
	}

	for(int i=0;i<len-1;i++)
	{
		swap(&ar[0],&ar[len-1-i]);
		Adjust(ar,0,len-2-i);
	}
}

归并排序

时间O（nlogn） 空间O（n）稳定

void Merge(int *ar,int width,int len)
{
	int *br=(int *)malloc(sizeof(int)*len);
	int i=0;
	int low1=0;
	int high1=low1+width-1;
	int low2=high1+1;
	int high2=low2+width-1<len?low2+width-1:len-1;

	while(low2<len)
	{
		while(low1<=high1 && low2<=high2)
		{
			if(ar[low1]<ar[low2])
			{
				br[i++]=ar[low1++];
			}
			else
			{
				br[i++]=ar[low2++];
			}
		}
		while(low1<=high1)
		{
			br[i++]=ar[low1++];
		}
		while(low2<=high2)
		{
			br[i++]=ar[low2++];
		}
		low1=high2+1;
		high1=low1+width-1<len?low1+width-1:len-1;
		low2=high1+1;
		high2=low2+width-1<len?low2+width-1:len-1;
	}

	while(low1<len)
	{
		br[i++]=ar[low1++];
	}

	for(int j=0;j<len;j++)
	{
		ar[j]=br[j];
	}
	free(br);
}
void MergeSort(int *ar,int len)
{
	if(NULL==ar || len<1)
	{
		return ;
	}

	for(int i=1;i<len;i*=2)
	{
		Merge(ar,i,len);
	}
}

快速排序

时间O（nlogn） 空间O（logn）不稳定

int Partition(int *ar,int left,int right)
{
	int tmp=ar[left];
	
	while(left<right)
	{
		while(left<right && ar[right]>=tmp)
		{
			right--;
		}
		ar[left]=ar[right];
		while(left<right && ar[left]<=tmp)
		{
			left++;
		}
		ar[right]=ar[left];
	}
	ar[left]=tmp;

	return left;
}
void Quick(int *ar,int left,int right)
{
	int index=Partition(ar,left,right);
	if(index-left>1)
	{
		Quick(ar,left,index-1);
	}

	if(right-index>1)
	{
		Quick(ar,index+1,right);
	}
}
void Quick1(int *ar,int left,int right)
{
	int len=right-left+1;
	
	stack<int> st;
	st.push(left);
	st.push(right);

	while(!st.empty())
	{
		int high=st.top();st.pop();
		int low=st.top();st.pop();
		int index=Partition(ar,low,high);
		if(index-low>1)
		{
			st.push(low);
			st.push(index-1);
		}

		if(high-index>1)
		{
			st.push(index+1);
			st.push(high);
		}
	}
}
void QuickSort(int *ar,int len)
{
	if(NULL==ar ||len<1)
	{
		return ;
	}
	Quick1(ar,0,len-1);
}

基数排序

时间O（nlogn） 空间O（n+rd） 稳定

int MaxFig(int num)
{
	int count=0;
	while(num>0)
	{
		count++;
		num/=10;
	}
	return count;
}

int GetFigure(int num,int index)
{
	if(index<0)
	{
		return -1;
	}
	int Reval=0;
	while(index>0)
	{
		Reval=num%10;
		num/=10;
		index--;
	}
	return Reval;
}
void Radix(int *ar,int len,int fig)
{
	queue<int> qu[10];
	for(int i=0;i<len;i++)
	{
		int tag=GetFigure(ar[i],fig);
		qu[tag].push(ar[i]);
	}

	int j=0;
	for(int i=0;i<len;)
	{
		while(!qu[j].empty())
		{
			ar[i++]=qu[j].front();qu[j].pop();
		}
		j++;
	}
}
void RadixSort(int *ar,int len)
{
	if(NULL==ar || len<1)
	{
		return ;
	}
	int maxnum=0;
	for(int i=0;i<len;i++)
	{
		if(ar[i]>maxnum)
		{
			maxnum=ar[i];
		}
	}
	int fig=MaxFig(maxnum);

	for(int i=1;i<=fig;i++)
	{
		Radix(ar,len,i);
	}
	
}

测试

int main()
{

	int arr[11]={0};
	int len=sizeof(arr)/sizeof(arr[0]);

	srand((unsigned int)time(0));
	for(int i=0;i<len;i++)
	{
		arr[i]=rand()%100;
	}
	show(arr,len);

	//BubbleSort(arr,len);
	//show(arr,len);

	//Selectsort(arr,len);
	//show(arr,len);

	//InsertSort(arr,len);
	//show(arr,len);
	
	//shellsort(arr,len);
	//show(arr,len);

	//Heapsort(arr,len);
	//show(arr,len);

	//MergeSort(arr,len);
	//show(arr,len);

	//RadixSort(arr,len);
	//show(arr,len);

	QuickSort(arr,len);
	show(arr,len);

}