系列文章记录重回开发之路----1. 基本排序算法

本篇涉及的基本算法有：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序。

冒泡排序

//注：熟记冒泡排序，需要理解关键字  翻转
int bubble_sort(int *data, int length)
{
    int location, bubble;
    int temp;

    for (location = 0; location < length; location ++) {
        for (bubble = 0; bubble < length - location - 1; bubble ++) {
            if(data[bubble] > data[bubble + 1]) {
                temp = data[bubble];
                data[bubble] = data[bubble + 1];
                data[bubble + 1] = temp;
            }
        }
    }
    return 0;
}

选择排序

//注：该算法的关键字为： 挑
int select_sort(int *data, int length)
{
    int loca, select;
    int loca_min, data_temp;
    for (loca = 0; loca < length; loca ++) {
        loca_min = loca;
        for (select = loca + 1; select < length; select ++) {
            if ( data[loca_min] > data[select] ) {
                loca_min = select;
            }
        }
        data_temp = data[loca];
        data[loca] = data[loca_min];
        data[loca_min] = data_temp;
    }
}

插入排序

//该算法的关键字：置换（这个可能不大准确，如果有更好的想法，请告知）
int insert_sort(int *data, int length)
{
    int dot_loca;
    int inser_loca;
    int dot_temp;

    for (dot_loca = 0; dot_loca < length - 1; dot_loca++) {

        for (inser_loca = dot_loca + 1; inser_loca > 0 &&  \
                data[inser_loca] < data[inser_loca - 1]; inser_loca --) {
            dot_temp = data[inser_loca];
            data[inser_loca] = data[inser_loca - 1];
            data[inser_loca - 1] = dot_temp;
        }
    }
   return 0;
}

希尔排序

//shell排序的关键字：分批   交换
int shell_sort(int *data, int length)
{
    int gap;
    int temp;
    int loca, swap_loca;

    for (gap = length / 2; gap >= 1; gap = gap / 2) {

        for ( loca = gap; loca < length; loca++) {
            temp = data[loca];
            for ( swap_loca = loca - gap; swap_loca >=0 &&  \
               temp < data[swap_loca]; swap_loca = swap_loca - gap) {
               data[swap_loca + gap] = data[swap_loca];
            }
            data[swap_loca + gap] = temp;
        }
    }
    return 0;
}

归并排序

//归并排序的关键字： 二分  转存  递归
void merge(int *data, int *temp, int start, int middle, int end)
{
    int i,j,k;
    i = start;
    j = middle + 1;
    k = start;
    while (i <= middle && j <= end) {
        if (data[i] > data[j]) {
            temp[k++] = data[j++];
        } else {
            temp[k++] = data[i++];
        }
    }
    while (i <= middle) {
        temp[k++] = data[i++];
    }
    while (j <= end) {
        temp[k++] = data[j++];
    }
    for (i = start; i <= end; i ++) {
        data[i] = temp[i];
    }
}
int merge_sort(int *data, int *temp, int start, int end)
{
    if (start >= end) return 0;
    int middle;
    middle = start + (end - start) / 2;
    merge_sort(data, temp, start, middle);
    merge_sort(data, temp, middle + 1, end);
    merge(data, temp, start, middle, end);
}

快速排序

//快排关键思想，利用哨兵，充分利用已有空间，插入排序的升华。逻辑十分巧妙。
//快排关键字： 哨兵，递归，
void quick(int *data, int left, int right)
{
    if (left >= right) return;

    int i = left;
    int j = right;
    int key = data[left];

    while (i < j) {
        while (i < j && key <= data[j]) {
            j --;
        }
        data[i] = data[j];
        while (i < j && key >= data[i]) {
            i ++;
        }
        data[j] = data[i];
    }
    data[i] = key;
    quick(data, left, i - 1);
    quick(data, i + 1, right);
}
int quick_sort(int *data, int length)
{
    quick(data, 0, length - 1);
}