经典算法学习——冒泡排序

      冒泡排序是我们学习的第一种排序算法，应该也算是最简单、最常用的排序算法了。不管怎么说，学会它是必然的。今天我们就用C语言来实现该算法。示例代码已经上传至：https://github.com/chenyufeng1991/BubbleSort

算法描述如下：

（1）比较相邻的前后两个数据，如果前面数据大于后面的数据，就将两个数据交换；

（2）这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就到了最后一个位置，也就是下标为N-1的位置（沉到了水底）。

（3）N = N-1，如果N不为0就重复（1）（2）两步，否则排序完成，也就是对数组的第0个数据到N-2个数据再次进行遍历；

完整的代码实现如下：

//
//  main.c
//  BubbleSort
//
//  Created by chenyufeng on 16/1/28.
//  Copyright © 2016年 chenyufengweb. All rights reserved.
//


#include <stdio.h>

typedef int BOOL;
#define true 1
#define false 0

int *bubbleSort01(int arr[],int len);
void bubbleSort03(int arr[],int len);

int main(int argc, const char * argv[]) {

    int array[7] = {150,111,1000,99,300,10,189};

    /**
     *指针向后移位；
     */

    //    int *p = bubbleSort02(array, 7);
    //
    //    for (int i = 0; i < 7; i++) {
    //        printf("%d ",*(p+i));
    //    }

    /**
     *  可以使用传引用的方式，实现如下;
     这里不需要返回值，直接打印即可,推荐使用这种方式，方便；
     */
    bubbleSort04(array, 7);
    for (int i = 0; i < 7; i++) {
        printf("%d ",array[i]);
    }

    return 0;
}

//常规的冒泡；
int *bubbleSort01(int arr[],int len){

    int temp;
    for (int i = 0; i < len; i++){
        for (int j = 1; j < len - i; j++) {
            if (arr[j - 1] > arr[j]) {

                temp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

//常规的冒泡，不需要返回值；
void bubbleSort03(int *arr,int len){

    int temp;
    for (int i = 0; i < len; i++){
        for (int j = 1; j < len - i; j++) {
            if (arr[j - 1] > arr[j]) {

                temp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

当然也可以把上面的交换元素的代码抽取出来，写成一个交换函数swap。代码实现如下：

//
//  main.c
//  BubbleSort
//
//  Created by chenyufeng on 16/1/28.
//  Copyright © 2016年 chenyufengweb. All rights reserved.
//


#include <stdio.h>

typedef int BOOL;
#define true 1
#define false 0

int *bubbleSort01(int arr[],int len);
void swap(int *a,int *b);

int main(int argc, const char * argv[]) {

    int array[7] = {150,111,1000,99,300,10,189};

    /**
     *指针向后移位；
     */

    //    int *p = bubbleSort02(array, 7);
    //
    //    for (int i = 0; i < 7; i++) {
    //        printf("%d ",*(p+i));
    //    }

    /**
     *  可以使用传引用的方式，实现如下;
     这里不需要返回值，直接打印即可,推荐使用这种方式，方便；
     */
    bubbleSort01(array, 7);
    for (int i = 0; i < 7; i++) {
        printf("%d ",array[i]);
    }

    return 0;
}

//常规的冒泡；
int *bubbleSort01(int arr[],int len){

    int temp;
    for (int i = 0; i < len; i++){
        for (int j = 1; j < len - i; j++) {
            if (arr[j - 1] > arr[j]) {

//                temp = arr[j - 1];
//                arr[j - 1] = arr[j];
//                arr[j] = temp;

                //这里也可以使用swap交换函数；
                swap(&arr[j - 1], &arr[j]);
            }
        }
    }
    return arr;
}


void swap(int *a,int *b){

    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

交换类排序：借助数据元素之间的相互交换进行排序的一种方法。如冒泡排序、快速排序。

插入类排序：将无序的各个元素依次插入到已经有序的线性表中。如直接插入排序、希尔排序。

选择排序：扫描整个线性表，选出最小的元素，将它交换到表的最前面；然后对剩下的继续同样的方法，直到子表为空。如直接选择排序、堆排序。

     说明下，冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1).是一种稳定的排序。

本文参考：http://blog.csdn.net/morewindows/article/details/6657829