常用的几种排序方法：冒泡、插入、选择、快排、归并排序
1、冒泡
以升序为例,也是有两种思路，（1）num[0]依次与后面比较将最小的放到第一位（2）将最大的放到最后一位。我比较习惯用第一种
（1）#include <iostream>
#include <cstdio>
using namespace std;
int main()
{
int a;
int num[100];
int b;
cin>>a;
for(int i=0;i<a;i++)
cin>>num[i];
for(int i=0;i<a-1;i++)
for(int j=i+1;j<a;j++)
{
if(num[i]>num[j])
{
b=num[i];
num[i]=num[j];
num[j]=b;
}
}
for(int i=0;i<a;i++)
cout<<num[i]<<endl;
return 0;
}
（2）
- #include <iostream>
- using namespace std;
- #define MAXN 100
- int a[MAXN + 1]; //全局变量存数组
- int main()
- {
- cout<<"=========冒泡排序一=========="<<endl;
- int i = 0, j;
- int T;
- int temp;
- cout<<"请输入要对数据排序的个数:"<<endl;
- cin>>T;
- cout<<"请输入要排序的数据:"<<endl;
- while(T--)
- {
- cin>>a[i];
- i++;
- }
- int len=i;//数组有效长度
- for(i=0;i<len-1;i++)
- {
- for(j=0;j<len-1-i;j++)
- {
- if(a[j]>a[j+1])
- {
- temp=a[j+1];
- a[j+1]=a[j];
- a[j]=temp;
- }
- }
- }
- cout<<"排序后的数据是:"<<endl;
- for(j = 0; j < len; j++)
- {
- cout<<a[j]<<" ";
- }
- cout<<endl;
- return 0;
- }
2、插入
插入排序(insertion sort)的基本思想：每次将一个待排序的记录，按其关键字大小插入到前面已经排序好的序列中，直到全部记录插入完成为止.
时间复杂度，最差、平均都是O(n*n)，最好是O(n)，空间复杂度 1，是一种稳定的排序
#include <iostream>
#include <cstdio>
using namespace std;
int main()
{
int a;
int num[100];
int b,j;
cin>>a;
for(int i=0;i<a;i++)
cin>>num[i];
for(int i=1;i<a;i++)
{
b=num[i];
for(j=i-1;j>=0;j--)
{
if(b<num[j])
{
num[j+1]=num[j];
}
else
break;
}
num[j+1]=b;
}
for(int i=0;i<a;i++)
cout<<num[i]<<endl;
return 0;
}
3、选择排序
先把0位置设置为索引，接着用index（索引）向后找最小的， 每一趟分别把最小的放在前面，然后和原来前面的数据交换位置。
时间复杂度，最差、平均都是O(n*n)，空间复杂度 1，是一种不稳定的排序
#include <iostream>
#include <cstdio>
using namespace std;
int main()
{
int a;
int num[100];
int b,j,p;
cin>>a;
for(int i=0;i<a;i++)
cin>>num[i];
for(int i=0;i<a;i++)
{
b=i;
for(j=i+1;j<a;j++)
{
if(num[j]<num[b])
b=j;
}
if(b!=i)
{
p=num[i];
num[i]=num[b];
num[b]=p;
}
}
for(int i=0;i<a;i++)
cout<<num[i]<<endl;
return 0;
}
4、快速排序
时间复杂度，最差O(n*n)，平均是O(n*logn)，空间复杂度 O(logn)，是一种不稳定的排序
#include <iostream>
#include <cstdio>
using namespace std;
int Findpos(int *a,int low,int high)
{
int val=a[low];
while(low<high)
{
while(low<high&&a[high]>=val)
--high;
a[low]=a[high];
while(low<high&& a[low]<=val)
++low;
a[high]=a[low];
}
a[low]=val;
return low;
}
void QuickSort(int *a,int low,int high)
{
int pos;
if(low<high)
{
pos=Findpos(a,low,high);
QuickSort(a,low,pos-1);
QuickSort(a,pos+1,high);
}
}
int main()
{
int a;
int num[100];
int b,j,p;
cin>>a;
for(int i=0;i<a;i++)
cin>>num[i];
QuickSort(num,0,a-1);
for(int i=0;i<a;i++)
cout<<num[i]<<" ";
return 0;
}
5、归并排序
分治的基本思想：是将原来的问题分解成若干个规模更小但结构与原问题想死的子问题，然后递归去解决这些子问题，最后将这些子问题的解的组合作为原问题的解。
首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。
可以看出合并有序数列的效率是比较高的，可以达到O(n)
解决了上面的合并有序数列问题，再来看归并排序，其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？
可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。
- #include <iostream>
- using namespace std;
- #define MAXN 100
- int a[MAXN + 1]; //全局变量存数组,初始值
- //将有二个有序数列a[first...mid]和a[mid...last]合并。
- void mergearray(int a[], int first, int mid, int last, int temp[])
- {
- int i = first, j = mid + 1;
- int m = mid, n = last;
- int k = 0;
- while (i <= m && j <= n)
- {
- if (a[i] <= a[j])
- temp[k++] = a[i++];
- else
- temp[k++] = a[j++];
- }
- while (i <= m)
- temp[k++] = a[i++];
- while (j <= n)
- temp[k++] = a[j++];
- for (i = 0; i < k; i++)
- a[first + i] = temp[i];
- }
- void mergesort(int a[], int first, int last, int temp[])
- {
- if (first < last)
- {
- int mid = (first + last) / 2;
- mergesort(a, first, mid, temp); //左边有序
- mergesort(a, mid + 1, last, temp); //右边有序
- mergearray(a, first, mid, last, temp); //再将二个有序数列合并
- }
- }
- bool MergeSort(int a[], int n)
- {
- int *p = new int[n];
- if (p == NULL)
- return false;
- mergesort(a, 0, n - 1, p);
- delete[] p;
- return true;
- }
- int main()
- {
- cout<<"=========归并排序一=========="<<endl;
- int i = 0, j;
- int T;
- cout<<"请输入要对数据排序的个数:"<<endl;
- cin>>T;
- cout<<"请输入要排序的数据:"<<endl;
- while(T--)
- {
- cin>>a[i];
- i++;
- }
- int len=i;//数组有效长度
- if(MergeSort(a,len)==true)
- {
- cout<<"排序后的数据是:"<<endl;
- for(j = 0; j < len; j++)
- {
- cout<<a[j]<<" ";
- }
- cout<<endl;
- }
- return 0;
- }
- 时间复杂度，最差、平均、最好都是O(n*logn)，空间复杂度O(n)，是一种稳定的排序
- 6、堆排序
-
/*堆排序(大顶堆) 2011.9.14*/ #include <iostream> #include<algorithm> using namespace std; void HeapAdjust(int *a,int i,int size) //调整堆 { int lchild=2*i; //i的左孩子节点序号 int rchild=2*i+1; //i的右孩子节点序号 int max=i; //临时变量 if(i<=size/2) //如果i不是叶节点就不用进行调整 { if(lchild<=size&&a[lchild]>a[max]) { max=lchild; } if(rchild<=size&&a[rchild]>a[max]) { max=rchild; } if(max!=i) { swap(a[i],a[max]); HeapAdjust(a,max,size); //避免调整之后以max为父节点的子树不是堆 } } } void BuildHeap(int *a,int size) //建立堆 { int i; for(i=size/2;i>=1;i--) //非叶节点最大序号值为size/2 { HeapAdjust(a,i,size); } } void HeapSort(int *a,int size) //堆排序 { int i; BuildHeap(a,size); for(i=size;i>=1;i--) { //cout<<a[1]<<" "; swap(a[1],a[i]); //交换堆顶和最后一个元素，即每次将剩余元素中的最大者放到最后面 //BuildHeap(a,i-1); //将余下元素重新建立为大顶堆 HeapAdjust(a,1,i-1); //重新调整堆顶节点成为大顶堆 } } int main(int argc, char *argv[]) { //int a[]={0,16,20,3,11,17,8}; int a[100]; int size; while(scanf("%d",&size)==1&&size>0) { int i; for(i=1;i<=size;i++) cin>>a[i]; HeapSort(a,size); for(i=1;i<=size;i++) cout<<a[i]<<" "; cout<<endl; } return 0; }
冒泡是按大小位置先确定依次找位置，和选择排序不同的是，冒泡每次比较大小都要交换位置，但是选择排序是先确定最小值的位置，再进行交换。
插入排序是从第一个元素开始让数列有序，如果带插入元素比有序的大，直接插在最后面，如果比有序的最后一个小，那依次往前比较，寻找比它小的插在它的后面，每一次往前比较时有序数列往后依次移动
快速排序是根据元素的值找它的位置，先找第一个元素的位置，两个指针分别从高低遍历，高指针先开始遇到比第一个小的就放到第一个，低指针后开始，遇到比它大的放到空位置，直到高低指针相当就是第一个元素的位置
3890
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
