黑马程序员－排序(冒泡，选择，快速排序)

------- android培训、java培训、期待与您交流！ ----------

排序很基础，却很重要，每次我遇到排序，总觉得名字和程序对不上号，而且不能立即就正确的编出来，正好黑马要求写博客，我就将排序凑上一份子啦。

常用的排序有：冒泡排序，选择排序，快速排序。

1，冒泡排序

一个是从大到小，一个是从小到大排序，从小到大的说法是：是大数下沉，小数上浮，感觉很贴切，通过相邻的俩数比较，如果上面的大于下面的数，就将上面的数与下面的数对调，即大数下沉，小数上浮。

//
//  main.c
//  冒泡排序
//
//  Created by cqycomputer on 15/6/16.
//  Copyright (c) 2015年 cqycomputer. All rights reserved.
//

#include <stdio.h>



void maoPao(int a[],int len){
    for(int i=0;i<len-1;i++){
        for(int j=0;j<len-1-i;j++){
            if(a[j]>a[j+1]){
                int tem = a[j];
                a[j] = a[j+1];
                a[j+1] = tem;
            }
        }
    }
}


int main(int argc, const char * argv[]) {
    // insert code here...
    printf("Hello, World!\n");
    
    int a[10]={5,9,1,4,6,3,2,8,0,7};
    for(int i=0;i<10;i++){
        printf("%d\t",a[i]);
        
    }
    printf("\n");
    
    maoPao(a, 10);
    for(int i=0;i<10;i++){
    printf("%d\t",a[i]);
    
    }
    
    return 0;
}

2，快速排序

快速排序我是一直很模糊的，很庆幸，今天又将快速排序温习了一遍，不然别人我我快速排序我会俩眼发呆的。

快速排序，是先选个基数，一般为要排序的第一个数，然后将所有比这个数小的放在这个数前面，比这个数大的放在这个数后面。今天看到一个很好很形象的说法，叫挖坑填数。

我觉得经典的程序，就是越品越有味。今天突然觉得快速排序的思想真是太精妙了。我借用前辈们的说法，用挖坑来描述。

首先，有十个数（假设是长度为10 的数组，需要就数按从小到大排序），现在旁边挖个坑，然后将十个数的第一个数挖出来，填在旁边的坑里，（局部变量，保存基数）这样第一个坑就出来了。

//
//  main.c
//  quick
//
//  Created by cqycomputer on 15/6/21.
//  Copyright (c) 2015年 cqycomputer. All rights reserved.
//

#include <stdio.h>


void quickSort(int a[],int low,int high){
    int selectNum = a[low];//变量，保存基数，即，在数旁边挖的坑。
    int i = low;// i 从数组前面开始寻找大于基数的数，
    int j = high;// j 从后面开始寻找小于基数的数，用于将i标记的大于基数的数与j标记的小于基数的数对调
    while(i<j){
        //基本思想：就是前后轮流挖坑，挖前面的坑，填后面的（小于基数的）数，挖后面的坑，填前面的（大于基数的）数。
        //之所以轮流，是因为始终只有一个坑，只能轮流来
        while(i<j && a[j]>=selectNum){
            j--;//之所以先从j开始，是因为坑是先从前面挖的。
        }
        if(i<j){
            a[i]=a[j];//第一个被填的数是a[0],a[0]已保存于selectNum中，所以这个坑可以被覆盖，覆盖完后，a[j]这个坑就挖出来了
            i++;//从被填坑的下一个寻找比基数大的值。
        }
        while(i<j && a[i]<selectNum){
            i++;
        }
        if(i<j){
            a[j] = a[i];//将寻找到的比基数大的值时，就将上面挖的a[j]这个坑填上，挖出a[i]新坑，于是一次轮流挖坑结束，
            j--;
        }
        

        
    }//判断条件始终有i<j,最后一次j--，使i=j
    a[i] = selectNum;
    for(int c=low;c<=high;c++){
        printf("%d\t",a[c]);
    }
    printf("\n");
    //下面通过递归调用，对基数前后的数再次重复操作
    if(i-1>low){
        quickSort(a,low,i-1);
    }
    if(i+1<high){
        quickSort(a,i+1,high);
    }
}



int main(int argc, const char * argv[]) {
    // insert code here...
    printf("Hello, World!\n");
    int arr[] = {5,6,8,7,4,1,3,2,9,0};
    quickSort(arr,0,9);
    for(int i=0;i<10;i++){
        printf("%d\t",arr[i]);
    }
        return 0;
}

3，选择排序

选择排序，就是一次寻找最小的（或者最大的），放在最前面（或者最后面），以按从小到大排序，将最小的放在前面，数组a，则，第一趟排序时，假设第一个是最小的，将其下标赋给一个变量 如 min ，从第二个开始，依次与a[min]对比，如果比a[min]小。则将第此下标赋给min，最后，获得的下标对应的数为最小的，将其与第一个数对调。

//
//  main.c
//  select
//
//  Created by cqycomputer on 15/6/21.
//  Copyright (c) 2015年 cqycomputer. All rights reserved.
//

#include <stdio.h>


void selectSort(int a[],int len){
    for(int i = 0;i < len -1;i ++){
        int min = i;//记录第i次最小值下标
        for(int j = i+1;j < len;j++){
            if(a[min] > a[j]){
                min = j;
            }
            
        }
        if(min != i){
            int tem = a[i];
            a[i] = a[min];
            a[min] = tem;
        }
    }
}

int main(int argc, const char * argv[]) {
    // insert code here...
    
    int arr[] = {5,6,8,7,4,1,3,2,9,0};
    selectSort(arr,10);
    for(int i=0;i<10;i++){
        printf("%d\t",arr[i]);
    }
    printf("Hello, World!\n");
    return 0;
}

小结；不得不说，即便是简单的程序，还是要运行一遍，上面的三个代码，只有选择排序是一次性通过的，而快速排序，因为我选的是第一个作为基数，最开始的时候，在递归调用快速排序时，没有判断low 与 i－1，high 与 i＋1 的大小，然后就出现问题了。

相对于单步调试，我喜欢将数值打印出来，这样感觉更快速，更简单。

------- android培训、java培训、期待与您交流！ ----------

详情请查看：http://edu.csdn.net/heima