归并排序,选择排序,插入排序,高效插入排序,快速排序

原创 2016年08月30日 20:12:07

本文总结了插入排序,归并排序,快速排序,选择排序4种方法,思路清晰,简单明了。


插入排序

特点:稳定,时间复杂度 O(n^2)

原理:以数组首端为已排序好的数列(虽然只有一个),从数组首端地址之后的待排序数组成员找到已经排序好的数列的插入位置,将待排序成员插入该位置,位置之后的成员依次往后移一位。

归并排序

特点:稳定,时间复杂度 O(nlog n)

原理:归,递归之意,并,合并之意,归:利用递归思路,分隔数组为2部分数组,不断递归,最终实际上得到只含有1个成员的数组,完成排序;归:假如两个数组均排好序,采用两指针对比大小,将两数组合并。

快速排序

特点:不稳定,时间复杂度 最理想 O(nlogn) 最差时间O(n^2)

原理:确定基准变量,从待排序数组选择大于和小于基准变量的成员,交换两成员位置,同时把基准变量放置于两成员之间,这样既可保证得到一个:小于基准变量,基准变量,大于基准变量的序列;利用递归进行循环,既可快速排序。

选择排序

特点:不稳定,时间复杂度 O(n^2)

原理:先选择整个数列的最大或最小值,放置于数组首端,去除该数字,再选择最大或最小值,放置于数组首端之后,依次循环。


程序输入:一组数值,数值之间空格,回车结束输入

程序输出:各类排序结果由小到大输出

sample input: 56 23 1 4 6

sample output: 1 4 6 23 56



#include <iostream>
using namespace std;
int result[1000];
		
void mergearray(int a[],int first,int mid ,int last)
{	
	int i,j,k,n,m;
	i=first;
	n=mid;
	j=mid+1;
	m=last;
	k=0;
	while(i<=n && j<=m)
	{
		if(a[i]<a[j])
		{
		result[k++]=a[i++];
		}
		else
		{
		result[k++]=a[j++];
		}
	}

	while(i<=n)
	{	
		result[k++]=a[i++];
	}
	while(j<=m)
	{	
		result[k++]=a[j++];
	}

	k=0;
	i=0;
	while(first+i<=last)
	{
		a[first+i]=result[k++];
		i++;
	}
}


void merge(int arr[],int first,int last)
{
	int mid=(first+last)/2;
	if(first<last)
	{
		merge(arr,first,mid);
		merge(arr,mid+1,last);
		mergearray(arr,first,mid,last);
	}

}

void choose(int arr[],int first,int last)
{
	for(int i=first;i<last;i++)
		for(int j=i+1;j<=last;j++)
			if(arr[j]<arr[i])
			{
				int temp=arr[i];
				arr[i]=arr[j];
				arr[j]=temp;
			}
}

void insert(int arr[],int first,int last)
{
	for(int i=first+1;i<=last;i++)
	{
		int tag=i;
		for(int j=i-1;j>=first;j--)
			if(arr[j]>arr[i])
			{
				tag=j;
			}

		if(tag!=i)
		{
			int temp=arr[i];
			for(int w=i-1;w>=tag;w--)
			arr[w+1]=arr[w];
		arr[tag]=temp;
		}
	}
}

void inserthigh(int arr[],int first,int last)
{
	for(int i=first+1;i<=last;i++)
	{
		int tempnum=i;
		for(int j=i-1;j>=first;j--)
			if(arr[j]>arr[tempnum])
			{
				int temp=arr[tempnum];
				arr[tempnum]=arr[j];
				arr[j]=temp;
				tempnum=j;
			}	
	}
}

void quicksort(int arr[],int first,int last)
{		
	int leftpoint=first;
	int rightpoint=last;
	int base=arr[first];
	int temp=0;
	if(leftpoint>=rightpoint)
		return;
			
	while(leftpoint!=rightpoint)
	{
		while(arr[rightpoint]>=base && leftpoint<rightpoint )
		rightpoint--;
		while(arr[leftpoint]<=base && leftpoint<rightpoint)
		leftpoint++;

		if(leftpoint<rightpoint)
		{			
		temp=arr[rightpoint+1];
		arr[leftpoint+1]=arr[rightpoint+1];
		arr[rightpoint+1]=temp;
		}
	}

	int middle=(leftpoint+leftpoint)/2;
	arr[first]=arr[middle];
	arr[middle]=base;

	quicksort(arr,first,middle);
	quicksort(arr,middle+1,last);

}

int main()
{
	int array[1000];
	int casenum=0;
	int arraynum=0;

	while(cin>>array[arraynum] )
	{
	arraynum++;
	if(getchar() == '\n') break;
	}

	cout<<"排序前数组为:   "<<endl;
	for(int i=0;i<arraynum;i++)
		cout<<array[i]<<" ";
	
	cout<<endl<<"请选择排序方法(0-归并排序,1-选择排序,2-插入排序,3-高效插入排序,4-快速排序):"<<endl;
	cin>>casenum;
	switch(casenum)
	{
	case 0: merge(array,0,arraynum-1);
			cout<<endl<<"归并排序结果:"<<endl;
			break;
	case 1: choose(array,0,arraynum-1);
			cout<<endl<<"归并排序结果:"<<endl;
			break;
	case 2:	insert(array,0,arraynum-1);
			cout<<endl<<"插入排序结果:"<<endl;
			break;
	case 3:	inserthigh(array,0,arraynum-1);
			cout<<endl<<"高效插入排序结果:"<<endl;
			break;
	case 4:	quicksort(array,0,arraynum-1);
			cout<<endl<<"快速排序结果:"<<endl;
			break;
	default:	cout<<endl<<"您的输入有误,排序失败,原结果为:"<<endl;	
	}
	
	for(int i=0;i<arraynum;i++)
		cout<<array[i]<<" ";

	int pause;
	cin>>pause;
	return 1;
}

版权声明:本文为博主原创文章,未经博主允许不得转载。 举报

相关文章推荐

快速排序、归并排序与选择排序平均时间之比较

#include#include#includeusing namespace std; void Merge(int Array[],int TempArray[],int low,int high...

冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序六大排序大总结

1、冒泡排序2、选择排序3、插入排序4、希尔排序5、快速排序6、归并排序

我是如何成为一名python大咖的?

人生苦短,都说必须python,那么我分享下我是如何从小白成为Python资深开发者的吧。2014年我大学刚毕业..

内排序(插入排序、冒泡排序、选择排序、shell排序、快速排序、归并排序、堆排序)

插入排序:逐个处理待排序的记录。每个新纪录与前面已排序的子序列进行比较,将它插入到子序列中正确的位置。 template  void inssort(E A[], int n) { // Ins...

排序算法----冒泡排序+插入排序+选择排序+快速排序+希尔排序+堆排序+归并排序+计数排序+基数排序+桶排序(c语言)

c语言实现各种排序算法

常见比较排序算法的实现(归并排序、快速排序、堆排序、选择排序、插入排序、希尔排序)

这篇博客主要实现一些常见的排序算法。例如: //冒泡排序 //选择排序 //简单插入排序 //折半插入排序 //希尔排序 //归并排序 //双向的快速排序 //单向的快速排序 //...

数据结构与算法从零开始系列:冒泡排序、选择排序、插入排序、希尔排序、堆排序、快速排序、归并排序、基数排序

本篇内容包含 排序的介绍 排序的C的实现 排序的Java的实现 排序的时间复杂度的计算 (一)冒泡排序1、基本思想:两个数比较大小,较大的数下沉,较小的数冒起来2、实现步骤:这张图就是将数字12,35...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)