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

原创 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;
}

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

相关文章推荐

插入排序 快速排序 分析整理

1、插入排序 插入排序是将一个元素插入到已经排好序的子序列中,实现下,n表示数组的长度。在排第i元素时,先将第i个元素暂存(temp=a[i]),然后i-1个位置开始依次将比a[i]大的元素后移。最终...

比较排序之插入和归并排序

排序之插入和归并插入排序: 对于少量的元素的排序,插入排序是一个很有效的算法。其原理很简单,类似于我们打扑克的时候,开始时,我们左手为空并且桌上的牌面向下,然后,我们每次从桌子上拿走一张牌并将它...

各种排序总结(一)之--—冒泡排序、选择排序、快速排序

各种排序总结——冒泡排序、选择排序、快速排序        1、冒泡排序是比较经典的排序方法,是一种用时间换空间的排序方法。我总结了一下它的特点:(1)它的时间复杂度是;(2)每一趟相邻元素两两比较完...

Map的插入操作和按照value排序

背景对比map的插入操作效率说明常见的map插入操作有两种,一种是通过操作符[]进行插入,另一种则是通过insert成员函数进行插入。 []操作符进行插入。[]操作符示例:std::map map1...
  • ljp1919
  • ljp1919
  • 2016年06月02日 10:04
  • 2235

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

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

排序算法: 冒泡排序, 快速排序,希尔排序,直接插入排序 ,直接选择排序,归并排序,堆排序

几种排序算法分析:     冒泡排序:   冒泡排序的方法排序速度比较慢。   思路:进行n-1排序,第一次排序先找出最小的数字,放在第一个位置,然后在剩余的数字中再找出最小的数字,放在第二个...

蛮力算法: 选择排序 冒泡排序(详解)

蛮力法:蛮力法(brute force)是一种简单直接地解决问题的方法,常常直接基于问题的描述和所涉及的概念定义。 虽然巧妙而高效的算法很少来自于蛮力法,但它还是具有重要地位。因为它能解决几乎任何问...

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

c语言实现各种排序算法
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:归并排序,选择排序,插入排序,高效插入排序,快速排序
举报原因:
原因补充:

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