Snail—算法学习之内部排序

说到排序 就是使得数据按照一定的规则排列起来 使得更好的对数据进行各种操作

文章的题目内部的意思就是数据量小，数据直接在内存中就可以排序

而相对来说的外部 就是需要访问外部数据了 比如网络上的、硬盘上得等等

一、交换排序—冒泡排序

//冒泡排序
/*
 最传统的思想就是 每循环一次 把最大的那个数 冒到最后
 12 32 34 22 12 35 21 57 49 9
 12 32 22 12 34 21 35 49 9 57
 12 22 12 32 21 34 35 9 49 57
 12 12 22 21 32 34 9 45 49 57
 12 12 21 22 32 9 34 45 49 57
 12 12 21 22 9 32 34 45 49 57
 12 12 21 9 22 32 34 45 49 57
 12 12 9 21 22 32 34 45 49 57
 12 9 12 21 22 32 34 45 49 57
 9 12 12 21 22 32 34 45 49 57
 */

void bubbleSort(int array[],int arryaLength){
    for (int i = 0; i < arryaLength ; i++) {
        for (int j = 0; j < arryaLength - i; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}


int main(int argc, const char * argv[]){
    int array[] = {12,32,34, 22, 12, 35, 21, 57, 49, 9};
    bubbleSort(array, 10);
    return 0;
}

下面我们对上面的算法可以做一下改进 我们用pos来记录一下每次排序完成后的位置 让它外层循环到pos这个位置就可以了，没必要再循环到整个数组的末尾

void bubbleSort_1(int array[],int arrayLength){
    int i = arrayLength;
    while (i > 0) {
        int pos = 0;
        for (int j = 0; j < i; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                pos = j;
                array[j + 1] = temp;
            }
        }
        i = pos;
    }
}

上面的这些算法 就只是 要么从小排到大 要么从大排到小 我们也可以让这两种情况同时进行

void bubbleSort_2(int array[],int arrayLength){
    //low、high记录一下初始位置
    int lowIndex = 0;
    int highIndex = arrayLength - 1;
    while (lowIndex < highIndex) {
        for (int j = lowIndex; j < highIndex; j++) {
            if (array[j] > array[j + 1]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
        lowIndex++;
        for (int j = highIndex; j > lowIndex; j--) {
            if (array[j] < array[j - 1]) {
                int temp = array[j];
                array[j] = array[j - 1];
                array[j - 1] = temp;
            }
        }
        highIndex--;
    }
}

二、交换排序—快速排序

快速排序 是用的分治策略 

可以看到下面的代码   以我的看法 就是 设置一个pk，作为基准数  一般设为数组的第一个 然后比基准数小的放到基准数的左边，大得放到基准数的右边

然后 首部a[low]，尾部a[high]

如果 a[high] > pk 那么让high--, 一直到a[high] <= pk，然后交换a[low] 和 a[high];

然后 再从low那边进行一下排序  如果a[low] < pk 那么low++,直到a[low]>=pk,交换a[low] 和 a[high];

//快速排序
void swap(int * a,int * b){
    int temp = *a;
    *a = *b;
    *b = temp;
}

int partition(int a[],int low,int high){
    
    int pk = a[low];
    while (low < high) {
        while (low < high && a[high] >= pk)
            high--;
        swap(&a[low], &a[high]);
        while (low < high && a[low] <= pk)
            low++;
        swap(&a[low], &a[high]);
    }
    return low;
}

void quickSort(int a[],int low,int high){
    if (low < high) {
        int pkIndex = partition(a, low, high);
        quickSort(a, low, pkIndex -1);
        quickSort(a, pkIndex + 1, high);
    }
    for (int i = 0; i < high; i++) {
        printf("%d ",a[i]);
    }
    printf("\n");
}

三、选择排序—简单选择排序

拿出一个数来跟其他的数比较 直到找到满条件的 才交换一次

//选择排序
void selectSort(int array[],int arrayLength){
    for (int i = 0; i < arrayLength - 1; i++) {
        for (int j = i + 1; j < arrayLength; j++) {
            if (array[i] > array[j]) {
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
    }
}