【排序算法】排序算法大全

排序算法在算法里面算是最常见的算法，这个blog主要是讲述内部排序的算法。包括常见的冒泡算法，双向冒泡算法，快速排序，希尔排序，插入排序，选择排序，堆排序。下面听我慢慢道来。

1、冒泡排序算法

这个毋庸解释，太熟悉了。本质就是，两重循环，外层循环用来找1—N-1个位置，里层循环用来找每个位置的最值（例如从小到大 排，则依次是最小的，第二小的，第三小的...），算法的复杂度是O（N2），计算量是(N-1)+（N-2）+...+2+1.注意计算复杂度（这里特指时间复杂度）是指在最坏的情况下执行交换或者运算的次数，不包括判断或者比较的次数（个人观点，错误之处望指正）

附上程序：

#include <iostream>
#include <cstdlib>
using namespace std;
int main()
{
int array[1000];
while (cin)
{
int temp,m;
cin >> m;//m表示该行有几个数
for (int i1 = 0; i1 < m; i1++)
{
cin >> array[i1];
}
for (int i2 = 0; i2 < m;i2++)
{
for (int i3 = (i2 + 1); i3 < m; i3++)
{
if (array[i2]>array[i3])
{
temp = array[i2];
array[i2] = array[i3];
array[i3] = temp;
}

}
}
for (int i4 = 0; i4 < m; i4++)
{
cout << array[i4] << "  ";
}
cout << endl;

}
system("pause");
return 0;
}

别人写的，从写程序的手法上就能看到差距，写的特别有条理，思路特别清晰

#include  
<stdio.h>
#include <stdlib.h>  
#include <time.h>  
#define MAX 11  
void input(int num[])
{
int i;


srand((unsigned)time(NULL));
for (i = 1; i<MAX; i++)
num[i] = rand() % 100;
}
void output(int num[])
{
int i;


for (i = 1; i<MAX; i++)
{
printf("%5d", num[i]);
if (0 == i % 10)
printf("/n");
}
printf("/n");
}
void sort(int num[])
{
int i, j, tmp;
for (i = 1; i<MAX - 1; i++)
{
printf("bubble.../n");
for (j = 1; j<MAX - i; j++)
{
printf("%5d", num[j]);
if (num[j]>num[j + 1])
{
tmp = num[j];
num[j] = num[j + 1];
num[j + 1] = tmp;
}
}
printf("%5d/n", num[MAX - i]);


printf("bubble after.../n");
for (j = 1; j<MAX; j++)
printf("%5d", num[j]);
printf("/n");
}
}
/* bubble sort */
/*
void sort(int num[])
{
int i, j, tmp;
for(i=1; i<MAX-1; i++)
{
for(j=1; j<MAX-i; j++)
if(num[j]>num[j+1])
{
tmp=num[j];
num[j]=num[j+1];
num[j+1]=tmp;
}
}
}

void main()
{
int num[MAX];
printf("sort before.../n");
input(num);
output(num);
sort(num);
printf("sort after.../n");
output(num);
}

2、双向冒泡排序

双向冒泡算法就是，根据冒泡的算法每次找一个最值，扩展到一次找两个值，一个是最大一个是最小，分别放到两边，当两者放到重合的时候，表示排序已经完成。思路还是挺好的，但据说执行效率一般，和冒泡相差不大（怎么样可以测试出，各种算法的时间消耗和内存消耗呢？）附上程序：

#include <iostream>
using namespace std;
int main()
{
int array[1000];
while (cin)
{
int m,temp;//表示该次排序的个数
cin >> m;
for (size_t i1 = 0; i1 < m; i1++)
{
cin >> array[i1];
}


//排序部分
int low = 0;//定义变量从0开始
int high = m;
while (low < (high-1))//注意此处m在各个条件下，是否需要减一
{
for (size_t i2 = low; i2 < high; i2++)
{
if (array[low]>array[i2])
{
temp = array[low];
array[low] = array[i2];
array[i2] = temp;
}
}
low++;
for (size_t i3 = (high-1); i3 >= low; i3--)
{
if (array[high-1]<array[i3])
{
temp = array[high-1];
array[high-1] = array[i3];
array[i3] = temp;
}
}
high--;
}


//输出
for (size_t i4 = 0; i4 < m; i4++)
{
cout << array[i4] << "  ";
}
cout << endl;
}
return 0;
}

3、快速排序

快速排序的实质是，每次找一个参考值，然后将数组小于参考值放在一堆，大于参考值的放在另外一堆。在两堆中分别找一个中间值，然后继续分成大于和小于的两堆。直到最后排序完成，这种算法适合于数据量较大的情况。快速排序比较次数少、速度较快，因为在内部排序算法中是最好的一种排序方法。算法复杂度为O(N2).（递归真心不好整啊）

//快速排序算法
#include <iostream>
using namespace std;
void Quicksort(int a[], int N);
void Qsort(int a[], int left, int right);
int median(int a[], int left, int right);
void swap(int &a, int &b);
void insertsort(int a[], int n); 
#define cutoff 3//用来判断使用快速排序还是插入排序
int main()
{
int a[] = {8,1,4,9,6,3,5,2,7,0};
Quicksort(a, 10);
for (int m = 0; m < sizeof(a) / sizeof(a[0]); m++)
cout << a[m]<<"  ";
cout << endl;
return 0;
}
//驱动接口
void Quicksort(int a[],int N)
{
Qsort(a,0,N-1);
}
//具体实现
void Qsort(int a[],int left,int right)
{
int i,j;
i=left;
j=right;
if (left + cutoff <= right)
{
int pivot = median(a, left, right);
for (;;)
{
while (a[++i]<a[pivot]){};
while (a[--j]>a[pivot]){};
if (i < j)
swap(a[i], a[j]);
else
break;
}
swap(a[i], a[right]);
Qsort(a, left, i - 1);
Qsort(a, i + 1, right);
}
else
insertsort(&(a[left]), right - left + 1);

}
//找中间参考值
int median(int a[], int left, int right)
{
int temp;
temp = (left + right) / 2;
if (a[left] > a[temp])
swap(a[left], a[temp]);
if (a[left] > a[right])
swap(a[left], a[right]);
if (a[right] < a[temp])
swap(a[right], a[temp]);
swap(a[temp], a[right]);
return a[right];
}
//交换函数
void swap(int &a, int &b)
{
int temp = a;
a = b;
b = temp;
}
//插入排序核心程序
void insertsort(int a[], int n)
{
int i, j, temp;
for (int i = 1; i < n; i++)
{
temp = a[i];
j = i - 1;//j用来指定之前排好序的最后一个序号
while (j >= 0 && temp < a[j])
{
a[j + 1] = a[j--];//这段写的好，直接通过这种方式来进行交换数组中的值
}
a[j + 1] = temp;
}
}

4 希尔排序(也称缩小增量排序)

希尔排序实质上是取较大的间距m,相隔m的元素进行排序，排完后紧接着间隔m/2的元素进行排序，一直到间距为1完成排序。