part05-常用排序算法

1.冒泡算法

冒泡排序算法是最简单的排序算法
它的执行效率最低

int main(int argc, const char * argv[]) {
    int arr[10]={1,5,2,6,11,78,43,234,56,5};
    int len = sizeof(arr)/sizeof(arr[0]);
    int i = 0 , j = 0;
    for (i = len; i > 0; i--)
    {
        for (j = 0; j < i; j++)
        {
            if (arr[j] < arr[j+1])
            {
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
    }
    for (i = 0; i < len; i++)
    {
        printf("%d\n",arr[i]);
    }
    return 0;
}

2.选择排序
选择排序可以把数字直接放在最终位置上

与冒泡法的区别在于：冒泡法的每次内循环，都是跟旁边的数比较，而选排是同一个固定的数比较

/*选择排序：可以把数字直接放在最终位置上*/
#include <stdio.h>
void sel_sort(int* p_num,int size){
    int i = 0,j=0;
    for(i=size-1;i>0;i--){
        for(j=0;j<i;j++){
            if(*(p_num+j)>*(p_num+i)){
                int tmp = *(p_num+j);
                *(p_num+j)=*(p_num+i);
                *(p_num+i)=tmp;
            }
        }
    }
}
int main(){
    int num[] = {21,45,12,23,43,75,234,34};
    int i=0;
    int size = sizeof(num)/sizeof(num[0]);
    sel_sort(num,size);
    for(i=0;i<8;i++){
        printf("%d ",num[i]);
    }
    printf("\n");
    return 0;
}

3.插入排序

插入排序的思想是：假设前面的数字已经排序完成了，那么每次把后面的一个数字插入到前面已经排序完成的数字序列中合适的位置上

/*插入排序：前面的数字已经排好顺序，可以把数字直接放在最合适的位置上*/
#include <stdio.h>
void insert_sort(int* p_num,int size){
    int i = 0,j=0,num=0;
    for(i=1;i<size;i++){
        num=*(p_num+i);
        for(j=i-1;j>=0;j--){
            if(*(p_num+j)>num){
                *(p_num+j+1)=*(p_num+j);
            }else
                break;
        }
        //每次以num为基准，如果大于num的，都向前移动一位，遇到不大于的就保持原位不动，然后跳出循环，将num值赋值给这一位的后面
        *(p_num+j+1)= num;
        
    }
}
int main(){
    int num[] = {21,45,12,23,43,75,234,34};
    int i=0;
    int size = sizeof(num) / sizeof(num[0]);
    insert_sort(num,size);
    for(i=0;i<8;i++){
        printf("%d ",num[i]);
    }
    printf("\n");
    return 0;
}

4.快速排序

快速排序的思想是以找准一个基准数（通常用第一个数），将基准数和其他数比较，根据结果来互换位置，最后达到此基准数的前面所有数都比他小，后天所有数都比他大

（好吧，我都觉得用文字说不清楚，直接举个例子）

8 10 4 6 12 5 7 19(8和19比，不换位置，8和7比，换位置)
7 10 4 6 12 5 8 19
7 8 4 6 12 5 10 19（8和10比，换位置）
7 8 4 6 12 5 10 19（8和5比，换位置）
7 5 4 6 12 8 10 19（8和4比，不换，8和6比，不换，8和12比）
7 5 4 6 8 12 10 19（此时8左边的都比它小，右边的都比它大）

上面例子就是以8为基准数，实现的第一轮比较结果。

快排的实现一般采用递归的思想

#include <stdio.h>
void quick_sort(int* p_num,int size){
    if(size>0){
        int* p_start = p_num;
        int* p_end = p_num + size - 1;
        int num = *p_start;
        while(p_end>p_start){
            if(*p_start>*p_end){
                int tmp = *p_start;
                *p_start = *p_end;
                *p_end = tmp;
            }
            if(*p_start!=num){
                p_start++;
            }else{
                p_end--;
            }
            quick_sort(p_num,p_start-p_num);
            quick_sort(p_end+1,p_num+size-1-p_end);//p_start也可以
            //quick_sort(p_start+1,p_num+size-1-p_end);//p_start也可以
        }
    }
}
int main(){
    int num[] = {21,45,12,23,43,75,234,34};
    int i=0;
    quick_sort(num,8);
    for(i=0;i<8;i++){
        printf("%d ",num[i]);
    }
    printf("\n");
    return 0;
}

5.归并算法

归并的思想是假设一组数据已经分成两个数组，且每个数组都是按从大到小排列。此时从两个数组中选出最小的那个数据进行比较。将这两个小数据中更小的那个放到第三个数组。

依次按照刚才的思想，当所有的数据都放入第三个数组时，就完成了排序

（蛋疼，还是来个例子说明下）

假设下面的一组数据已经分成了两组，且每组都是排好了顺序

1 3 5 7  2 4 6 8
int a[8]={********};
1*******
12******(此时，第一组中最小的是3，第二组是4)
123*****
1234****
12345***
123456**
1234567*
12345678

/*
归并排序：假设所有数据分成两份，每份都从小到大排序，然后把两份中最小的放进一个临时数组，这样递归的进行，放完后再从临时数组中放回到原数组
*/
#include <stdio.h>
void merge_sort(int* p_value,int* p_temp,int start,int end){
  if(end>start){
    int mid = (start+end)/2+1;
    merge_sort(p_value,p_temp,start,mid-1);
    merge_sort(p_value,p_temp,mid,end);
    int first = start,second = mid,temp = start;
    while(first<mid||second<=end){
        if(first==mid){
            *(p_temp+temp)=*(p_value+second);
            second++;
        }else if(second>end){
            *(p_temp+temp)=*(p_value+first);
            first++;
        }else{
            if(*(p_value+first)>*(p_value+second)){
                *(p_temp+temp)=*(p_value+second);
                second++;
            }else{
                *(p_temp+temp)=*(p_value+first);
                first++;
            }
        }
        temp++;
    }
    int pos = 0;
    for(pos=start;pos<=end;pos++){
        *(p_value+pos)=*(p_temp+pos);
    }
  }
    
}
int main(){
    int values[] = {21,45,12,23,43,75,234,34};
    int i;
    for(i=0;i<8;i++){
        printf("%d ",values[i]);
    }
    printf("\n");
    int temp[8]={};
    merge_sort(values,temp,0,7);
    for(i=0;i<8;i++){
        printf("%d ",values[i]);
    }
    printf("\n");
    return 0;
}