算法基础_8大经典排序算法实现回顾

冒泡排序

//冒泡void sort(int ary[],int size){    int temp;    int hasChange;    //size-1次比较    for (int i = 0; i < size - 1; i++) {        hasChange = 0;        //前size-1-i个元素比较        for (int j = 0; j < size - 1 - i; j++) {                        if (ary[j] > ary[j+1]) {                temp = ary[j];                ary[j] = ary[j+1];                ary[j+1] = temp;                hasChange = 1;            }        }        //优化，如果此轮没有变化，后面就不用再比了        if (!hasChange) {            break;        }    }}

选择排序

void selectSort(int ary[],int size){    for (int i = 0; i < size; i++) {        int min = i;        int temp = ary[i];        for (int j = i + 1; j < size; j++) {            if (ary[j] <= ary[min]) {                min = j;//记录最小值坐标            }        }        ary[i] = ary[min];//将最小值交换到左侧        ary[min] = temp;    }}

直接插入排序

void insertSort(int unsorted[],int size){    //从头组建，左侧的都是排好的    for (int i = 1; i < size; i++)    {        int temp = unsorted[i];//记住待比较值        int j = i;//设置启始比较位置        // 待比较值往前一个一个比，若成立，将元素后移        while (j > 0 && unsorted[j - 1] > temp)        {            //往后挪            unsorted[j] = unsorted[j - 1];            j--;        }        //找到位置，将待比较值值插入        unsorted[j] = temp;    }}

折半插入排序

//折半插入排序,不用一个一个往前比，利用二分发找到合适位置void binaryInsertSort(int ary[],int size){    for (int i = 1; i < size; i++) {        int low = 0;        int high = i - 1;        int temp = ary[i];        while (low <= high) {            int mid = (low + high)/2;            if (temp > ary[mid]) {                low = mid + 1;            }            else{                high = mid - 1;            }        }        for (int j = i; j > low; j--) {            ary[j] = ary[j - 1];        }        ary[low] = temp;    }}

快速排序

void quickSort(int ary[],int left,int right){    if (left >= right) {        return;    }    int i = left;    int j = right;    int base = ary[i];    while (i < j) {        while (i < j && ary[j] >= base) {            j--;        }        if (i < j) {            ary[i] = ary[j];//把i填上，j空了        }                while (i < j && ary[i] <= base) {            i++;        }        if (i < j) {            ary[j] = ary[i];//j填上,i有空了        }    }    ary[i] = base;    quickSort(ary, left, i - 1);    quickSort(ary, i + 1, right);}

希尔排序

//先按增量分段,割裂成子序列进行直接插入，减少增量，重复，最后再进行一次直接插入排序void shellSort(int ary[],int size){    for (int gap = size/2; gap > 0; gap = gap/2) {//每次gap减半，确定间隔        for (int i = 0; i < gap; i++) {//每个组内启始点在gap范围内            for (int j = i + gap; j < size; j+=gap) {//找组内成员                    //直接插入排序                    int temp = ary[j];                    int k = j;                    while (k >= 0 && ary[k-gap] >= temp)                    {                        ary[k] = ary[k - gap];                        k -= gap;                    }                    ary[k] = temp;            }        }    }}

归并排序

//合并数组void mergeAry(int ary[],int f,int m,int l,int temp[]){    int midA = m + 1;    int i = 0;    int first = f;    //前后两部分(两部分组内都是有序的)合并到temp中    while (f <= m && midA <= l) {        if (ary[f] <= ary[midA]) {            temp[i++] = ary[f++];        }        else{            temp[i++] = ary[midA++];        }    }    while (f <= m) {        temp[i++] = ary[f++];    }    while (midA <= l) {        temp[i++] = ary[midA++];    }    //把合并好的temp,加回ary    for (int j = 0; j < i; j++) {        ary[first + j] = temp[j];    }}void mergeSort(int ary[],int f,int l,int temp[]){    if (f < l) {        int mid = (f+l)/2;        mergeSort(ary,f,mid,temp);//先不断分解        mergeSort(ary,mid + 1,l,temp);        mergeAry(ary, f, mid, l, temp);//再合并    }}

堆排序

/* //大根堆 小跟堆，父节点比大(小)于子节点 就是不断整理成堆的格式，输出堆顶，然后再调整 初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储顺序，使之成为一个堆，将堆顶元素输出，这时堆顶的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。 *///堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置//根放在0位置，以后假定当前位置是i，那么左子结点在2i+1，右子结点在2i+2//交换元素void swap(int ary[],int i,int j){    int temp = ary[i];    ary[i] = ary[j];    ary[j] = temp;}//大堆化void beMaxHeap(int ary[],int i,int length){    int l = 2 * i + 1;    int r = l + 1;    int max = i;    if (l < length && ary[l] > ary[i]) {        max = l;    }    if (r < length && ary[r] > ary[max]) {        max = r;    }    if (max != i) {        swap(ary, i, max);        //产生了交换，根被下移，破坏了子树的堆特性，继续逐级下降堆化        beMaxHeap(ary, max, length);    }}//初始化堆void buildMaxHeap(int ary[],int length){    for(int i = length/2 + 1;i>=0;i--){        beMaxHeap(ary, i, length);    }}//排序void heapSort(int ary[],int length){    //初始化堆    buildMaxHeap(ary, length);    int l = length;    for(int i = length - 1;i > 0;i--){        //将堆顶交换至末尾        swap(ary, 0, i);        l--;        //堆化        beMaxHeap(ary, 0, l);    }    }