基本排序方法：冒泡排序、简单选择排序、直接插入排序

 #返回上一级

@Author: 张海拔

@Update: 2014-01-11

@Link: http://www.cnblogs.com/zhanghaiba/p/3514440.html

/*
 *Author: ZhangHaiba
 *Date: 2014-1-10
 *File: basic_sort_algorithm.c
 *
 *a demo of basic sort algorithm including:
 *bubble sort
 *select sort
 *insert sort
 */

#include <stdio.h>
#define N 512

//public
void bubble_sort(int*, int);
void select_sort(int*, int);
void insert_sort(int*, int);
void insert_sort2(int*, int);
void set_array(int*, int);
void show_array(int*, int);
//private
void swap(int*, int*);

int array[N];

int main(void)
{
    int n;
    
    scanf("%d", &n);
    set_array(array, n);
    //basic sort algorithm
    insert_sort(array, n);
    show_array(array, n);
    return 0;
}

void bubble_sort(int *a, int n)
{
    int i, j;
    
    for (i = 0; i < n-1; ++i)
        for (j = 0; j < n-1-i; ++j)
            if (a[j] > a[j+1])
                swap(&a[j], &a[j+1]);
}

void select_sort(int *a, int n)
{
    int i, j, min_idx;

    for (i = 0; i < n-1; ++i) {
        min_idx = i;
        for (j = i; j < n; ++j)
            if (a[j] < a[min_idx])
                min_idx = j;
         swap(&a[i], &a[min_idx]);
    }
}

void insert_sort(int *a, int n)
{
    int i, j, key;

    for (i = 1; i < n; ++i) {
        key = a[i];
        for (j = i-1; j >= 0 && a[j] > key; --j)
            a[j+1] = a[j];
        a[j+1] = key;
    }
}

//a simple and concise implementation of insert_sort
void insert_sort2(int *a, int n)
{
    int i, j;
    
    for (i = 1; i < n; ++i)
        for (j = i-1; j >= 0 && a[j] > a[j+1]; --j)
            swap(&a[j], &a[j+1]);
}

void set_array(int *a, int n)
{
    int i;
    
    for (i = 0; i < n; ++i)
        scanf("%d", a+i);
}

void show_array(int *a, int n)
{
    int i;

    for (i = 0; i < n; ++i)
        printf(i == n-1 ? "%d
" : "%d ", a[i]);
}

void swap(int *a, int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

理解排序算法，需要掌握两个要点：

（1）排序通常是使待排序数组规模从n减到1（或看做已排序数组规模从1增到n）的过程；//规模为1的数组必然有序

（2）排序的问题规模减1这个过程，一般称为“一趟排序”；

冒泡排序(bubble_sort)：

冒泡排序是最易理解和编写的一个排序方法，由于一趟排序的过程有如气泡出水底中冒上来那样生动，因而得名。

冒泡排序通过依次让[0, n-1)的元素与它右边紧领（下称“右继”）的元素比较，使较大（或较小）的元素落在右边位置，

这样，对当前待排序数组按上述过程一次遍历，就能使最大（或最小）元素落在最右端，也就一趟排序后，待排序数组规模减1了。

规模从n减到1，需要n-1次，即通过n-1趟排序就能完成了整个排序。

代码中——

外循环for (i = 0; i < n-1; ++i)控制n-1趟排序，

内循环一次确保最大元素落在待排序数组的最右端：for (j = 0; j < n-1 - i; ++j)  if (a[j] > a[j+1]) swap(j, j+1);

简单选择排序(select_sort):

设min_idx是规模为n的待排序数组中已知元素中最小元素的下标；

为了维护min_idx值的意义，初始化为起始元素下标，（嗯，改名叫current_min_idx最适合）

并且在遍历待排序数组的过程中，始终维护min_idx始终记录当前已知元素中最小元素的下标（指向当前最小元素）；

这样，循环遍历结束时，min_idx为当前待排序数组中最小元素的下标。

此时交换当前数组最左元素与最小元素，即使未排序数组规模减1。

代码中——

显然外层循环控制n-1躺排序；

内存循环求出待排序数组中最大元素的下标，再交换最大元素与最左元素，使排排序数组规模减1。

 

直接插入排序(insert_sort)：

直接插入排序思路，与上述两种排序思路反过来想会更好理解——

即通过不断增加已排序数组的规模，最终得到规模为n的已排序数组。

最初，有序数组的规模是1（第一元素看做一个规模为1的已排序数组）。

已排序数组增1（从k到k+1）的过程（即一趟排序）是：

通过把 与已排序数组的右继元素 “有序地”插入到已排序数组（即插入到适当位置使数组仍有序，但规模必然加1）。

那么对于规模为i的已排序数组，设j=i-1（指向已排序数组的最后一个元素），

则从已排序数组的末尾元素a[j]开始，与其右继元素a[j+1]进行比较，若a[j+1]小则交换位置，

这样逆序两两比较，直到出现!(a[j] > a[j+1]) || j < 0，此时说明插入的元素已满足有序性，不再需要交换。

（再回味下这个过程，其实是让当前规模有序数组的右继元素，通过几次交换“有序地”插入到上述数组）

这样，已排序数组的规模加1。

代码中——

内循环for (j = i-1; j >= 0 && a[j] > a[j+1], ++j) swap(j, j+1); 其中i表示当前有序数组的规模；

外循环控制有序数组规模，规模从1开始（变换为2），一直到n-1（变换为n），因此有：for (i = 1; i < n; ++i)。

 

三个算法的比较：

我的实现中，冒泡排序和直接插入排序都可以用三行代码写完，简单选择排序则长了点。

而性能方面，虽然三者最坏情况都是O(n^2)，但冒泡排序和直接插入排序最好情况是O(n)，简单选择排序最好情况也是O(n^2)

最关健的是，冒泡排序和直接插入排序显然是稳定的，而简单选择则是不稳定的。举个例子(2, 2, 1)，一次排序后是(1, 2, 2)，显然2的相对次序改变了。

Hint:算法的稳定性是指：原始数据中相同的关键字的相对次序在排序后没有改变，则称这种排序算法是稳定的。

综合来看：简单选择排序比较挫了（代码长度、最好情况、稳定性都劣势），冒泡排序居中，直接插入排序对于数据“基本有序”则表现很好。

三个算法的改进：

（1）快速排序的基于冒泡排序来改进的，不过这次冒的泡不是最轻的，而是期望这个泡重量夹在中间，这样可以通过分治法使效率提升到O(n*logn)，但这种改进丢失冒泡稳定的特性。

（2）堆排序是基于选择排序改进，首先堆是指二叉堆这个数据结构，这个数据结构可以以O(logn)的效率求出最值，从而使选择选择排序效率提升到O(n*logn)，这种改进也丢失了简单选择稳定的特性。

（3）希尔排序是基于直接插入排序的改进，改进的基本原理是：当数组“基本有序”时，直接插入效率接近O(n)，然后通过隔空进行直接插入排序减小问题规使得相对效率提升，而随着隔空距离的减小，数据的“基本有序”的程序却在增大。通过数学证明，平均情况下希尔排序的效率提升到了O(n^(1.3))。

最后，对排序算法来个分类——

（1）交换类排序：冒泡排序、快速排序

（2）选择类排序：简单选择排序、堆排序

（3）插入类排序：直接插入排序、希尔排序

（4）归并类排序：归并排序

#返回上一级