各种排序算法

 

// 交换函数

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 voidmerge(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);

    }
}