各种排序算法

 

// 交换函数

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

// 冒泡排序

/* 冒泡排序（Bubble Sort，台湾译为：泡沫排序或气泡排序）是一种简单的排序算法。
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
冒泡排序对n个项目需要O(n2)的比较次数，且可以原地排序。尽管这个算法是
最简单了解和实作的排序算法之一，但它对于少数元素之外的数列排序是很没有效率的。
冒泡排序是与插入排序拥有相等的执行时间，但是两种法在需要的交换次数却很大地不同。
在最坏的情况，冒泡排序需要O(n2)次交换，而插入排序只要最多O(n)交换。
天真的冒泡排序实作（类似下面）通常会对已经排序好的数列拙劣地执行（O(n2)），
而插入排序在这个例子只需要O(n)个运算。因此很多现代的算法教科书避免使用冒泡排序，
而用插入排序取代之。冒泡排序如果能在内部循环第一次执行时，使用一个旗标来表示有
无需要交换的可能，也有可能把最好的复杂度降低到O(n)。在这个情况，在已经排序号的
数列就无交换的需要。若在每次走访数列时，把走访顺序和比较大小反过来，也可以些微
地改进效率。有时候称为往返排序（en:shuttle sort），因为算法会从数列的一端到另一
端之间穿梭往返。
冒泡排序算法的运作如下：
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
由于它的简洁，冒泡排序通常被用来对于程式设计入门的学生介绍算法的概念。
*/
void bubble_sort(int *arr, int len)
{
    int tmp = 0;
    for(int i = len -1; i > 0; i --)
    {
        for(int j = i - 1; j > 0; j --)
        {
            if(*(arr + i) < *(arr + j))
            {
                swap(arr+i, arr +j);
            }
        }
    }
}

/* 鸡尾酒排序，也就是定向冒泡排序, 鸡尾酒搅拌排序, 搅拌排序 (也可以视作选择排序的一种变形),
涟漪排序, 来回排序 or 快乐小时排序, 是冒泡排序的一种变形。此算法与冒泡排序的不同处在于排序
时是以双向在序列中进行排序。
*/

void cocktail_sort(int *arr, int len)
{
    int top = 0, bottom = len -1;
    int _swap = 1;
    int tmp = 0;
    while(_swap)
    {
        _swap = 0;
        for(int i = bottom; i > top; i --)
        {
            if(arr[bottom] < arr[i])
            {
                swap(&arr[bottom], &arr[i]);
                _swap = 1;
            }
        }
        
        bottom --;
        for(int i = top; i < bottom; i ++)
        {
            if(arr[top] > arr[i])
            {
                swap(&arr[top], &arr[i]);
                _swap = 1;
            }
        }
        top ++;
    }
}

void even_odd_sort(int * arr, int len)
{
    int tmp = 0;
    for(int i = len -1 ; i > len/2 -1 ; i--)
    {
        for(int j = 1; j < i; j += 2)
        {
            if(arr[j] > arr[j + 1])
                swap(&arr[j], &arr[j +1]);
        }

        for(int j = 0; j < i; j += 2)
        {
            if(arr[j] > arr[j + 1])
                swap(&arr[j], &arr[j +1]);
        }
    }
}

// 快速排序

void quick_sort(int * arr, int beg, int end)
{
    if(end > beg + 1)
    {
        int piv = arr[beg], k = beg +1, r = end;

        while(r > k)
        {
            if(arr[k] < piv)
                k++;
            else
                swap(&arr[k], &arr[r--]);
        }

        if(arr[k] < piv) // 如果剩下的那个数比标记小，则交换，这样就是这个数前面的都比它小，后面的都比它大，所以这个数就不用再排了。

        {
            swap(&arr[k], &arr[beg]);
            quick_sort(arr, beg, k - 1);
            quick_sort(arr, k + 1, end);
        }
        else // 如果剩下这个数大于或等于标记的数，那么将这个数的前一个与这个数交换，并对之前的和之后的分别排序。

        {
            if(end - beg == 1)
                return;
            swap(&arr[--k], &arr[beg]);
            quick_sort(arr, beg, k);
            quick_sort(arr, k + 1, end);
        }
    }
}

// 选择排序

void select_sort(int *arr, int len)
{
    for(int i = 0; i < len; i++)
    {
        for(int j = i + 1; j < len; j ++)
        {
            if(arr[i] > arr[j])
                swap(&arr[i], &arr[j]);
        }
    }
}


// 堆排序


static void build_heap(int *arr, int start, int end)
{
    int parent = start;
    int tmp = arr[start];
    int child = (start << 1) + 1;
    
    //i = start << 1; // the child of start;

     while(child <= end)
    {
        if(child < end)
        {
            if(arr[child] < arr[child + 1]) // 如果左子节点比右指节点小，则不管左子节点

                child ++;
        }

        if(arr[child] < tmp)
        {
            break;
        }
        else
        {
            //swap(arr + start, arr + i);

            arr[parent] = arr[child];
            parent = child;
            child = (child << 1) + 1;
        }
    }

    arr[parent] = tmp;
}
void heap_sort(int * arr, int len)
{
    int i;

    for(i = (len >> 1) -1; i >= 0; i --)
        build_heap(arr, i, len -1);
    for(i = len -1; i >= 0; i--)
    {
        swap(arr + i, arr);
        build_heap(arr, 0, i -1);
    }
}


// 插入排序

void insert_sort(int * arr, int len)
{
    int tmp = 0;
    int j = 0;
    for(int i = 1; i < len; i++)
    {
        tmp = arr[i];
        for(j = i; j > 0; j --)
        {
            if(tmp < arr[j -1])
                *(arr + j) = *(arr + j -1);
            else
            {
                break;
            }
        }
        arr[j] = tmp;
    }
}


// 希尔排序

void shell_sort(int * arr, int len)
{
    int step = len /2;
    int tmp = 0;
    int i = 0;
    int j = 0;
    while(step)
    {
        for(i = step; i < len; i += step)
        {
            j = i - step;
            tmp = arr[i];
            while(j >= 0 && tmp < arr[j])
            {
                arr[j + step] = arr[j];
                j -= step;
            }
            arr[j + step] = tmp;
        }

        step >>= 1;
    }
}

// 归并排序

static void merge(int * arr, int start, int mid, int end)
{
    int * sa1 = (int *)malloc(sizeof(int) *(end - start + 1));
    memcpy(sa1, arr + start, sizeof(int) *(end - start + 1));
    int *sa2 = arr + mid + 1;
    int len1 = mid -start +1;
    int len2 = end - mid;
    int i = 0, j = 0, k = start;
    while(i < len1 && j < len2)
    {
        if(sa1[i] < sa2[j])
            arr[k ++] = sa1[i ++];
        else
            arr[k ++] = sa2[j ++];
    }

    while(i < len1)
    {
        arr[k ++] = sa1[i ++];
    }

    while(j < len2)
    {
        arr[k ++] = sa2[j ++];
    }
    free(sa1);
}
void merge_sort(int * arr, int start, int end)
{
    if(start < end)
    {
        //int * p = (int *)malloc(sizeof(int) * (end - start + 1));

        //memcpy(p, arr, sizeof(int) * (end - start + 1));

        int mid = (start + end) / 2;
        merge_sort(arr, start, mid);
        merge_sort(arr, mid + 1, end);
        merge(arr, start , mid, end);
        //free(p);

    }
}