八种常见排序算法

冒泡排序：

• 动态图：

• 代码实现：

package 数据结构.排序;
import java.util.Arrays;
//每次循环都是先排好后面的
public class 冒泡排序 {
    public static void sort(int[] sourseArrays){
        for(int i = 0 ; i < sourseArrays.length-1;i++){
            for (int j = 0; j < sourseArrays.length-1-i; j++) {
                if(sourseArrays[j] > sourseArrays[j+1]){
                    int temp = sourseArrays[j];
                    sourseArrays[j] = sourseArrays[j+1];
                    sourseArrays[j+1] = temp;
                }
            }
            System.out.println(Arrays.toString(sourseArrays));
        }
    }

    public static void main(String[] args) {
        int[] a = {6,5,9,8,7,3,2,21,1};
        sort(a);
    }
}

选择排序：

• 动态图：

• 代码实现：

package 数据结构.排序;

import java.util.Arrays;
//每一次排序都是先排好前面的
public class 选择排序 {
    public static void sort(int[] sourseArray){
        for (int i = 0; i < sourseArray.length-1; i++) {
            for(int j = i+1;j< sourseArray.length;j++){
                if(sourseArray[i]> sourseArray[j]){
                    int temp = sourseArray[i];
                    sourseArray[i] = sourseArray[j];
                    sourseArray[j] = temp;
                }
            }
            System.out.println(Arrays.toString(sourseArray));
        }
    }

    public static void main(String[] args) {
        int[] a = {6,5,9,8,7,3,2,21,1};
        sort(a);
    }
}

插入排序：

• 动态图：

• 代码实现：

package 数据结构.排序;

import java.lang.reflect.Array;
import java.util.Arrays;

public class 插入排序 {
    public static void sort(int[] sourceArray) {
        for (int i = 1; i < sourceArray.length; i++) {//从下表为1开始，直到最后一个
            int tmp = sourceArray[i];
            int j = i;//没有排序序列的外面的第一个
            while (j>0&&sourceArray[j-1]>tmp){//sourceArray[j-1]<tmp(降序)
                //j-1>=0==>j>0;（先写）
                sourceArray[j] = sourceArray[j-1];
                j--;//在已经排完序的序列，j-1才是他们的下标
            }
            sourceArray[j] = tmp;//最后多减去了一次
            System.out.println(Arrays.toString(sourceArray));
        }
    }

    public static void main(String[] args) {
        int[] a = {6,5,9,8,7,3,2,21};
        sort(a);
    }
}

快速排序：

• 动态图：

• 代码实现：

package 数据结构.排序;

import java.util.Arrays;

public class 快速排序 {
    public static void sort(int[] arr, int left, int right) {
        int l = left;
        int r = right;
        int pivot = arr[(left + right) / 2];
        int tmp = 0;
        while (l < r) {//可以实现把数组分成左边比某个小，右边比某个大的
            while (arr[l] < pivot) {
                l++;
            }
            while (arr[r] > pivot) {
                r--;
            }
            if (l >= r) {
                break;
            }
            tmp = arr[l];
            arr[l] = arr[r];
            arr[r] = tmp;
            if (arr[l] == pivot) {
                r--;
            }
            if (arr[r] == pivot) {
                l++;
            }
        }
        if (l == r) {
            l++;
            r--;
        }
        if (left < r) {
            sort(arr, left, r);
        }
        if (right > l) {
            sort(arr, l, right);
        }
    }
    public static void main(String[] args) {
        int[] arr = {7,8,9,4,6,11,12,5,3};
        sort(arr, 0, arr.length - 1);
    }
}

希尔排序：

• 动态图：

• 代码实现：

package 数据结构.排序;

import java.util.Arrays;

//把元素按照下标的一定增量分组，一般情况下，初始分组为length/2，对每组使用直接插入排序算法排序，
//随着增量逐渐渐少，每组包含的元素越来越多，当增量减至为1的时候，整个序列恰好是一组，算
//法终止
public class 希尔排序 {
    public static void sort(int[] sourceArray) {
        for (int gap = sourceArray.length / 2; gap > 0; gap = gap / 2) {
            for (int i = gap; i < sourceArray.length; i++) {
                int tmp = sourceArray[i];
                int j = i;
                while (j - gap >= 0 && tmp < sourceArray[j - gap]) {
                    sourceArray[j] = sourceArray[j - gap];
                    j = j - gap;
                }if (j != i) {
                    sourceArray[j] = tmp;
                }
                System.out.println(Arrays.toString(sourceArray));
            }

        }
    }
    public static void main(String[] args) {
        int[] a = {6,5,9,8,7,3,2,21,1};
        sort(a);
    }
}

归并排序：

• 动态图：

• 代码实现：

package 数据结构.排序;
import java.util.Arrays;
//总结：对于偶数个数，那么最终会分成相邻两个一组的子序列，且每个子序列都会调用排序方法
//     对于奇数个数，那么最终会分成左起第二个是单个的，其他都是成对的，成对的都会调用方法排序，单个的不排序，
//     每个节点（树叶（成对），节点（包括根节点）的总和等于调用排序方法的次数）
public class 归并排序 {
    public static void main(String[] args) {
        int[] arr = {6, 5, 9, 3,2, 4,1,8,9};
        int[] temp = new int[arr.length];//合并空间
        sort(arr, 0, arr.length - 1, temp);//静态的主函数是可以调用静态的方法的
    }
    public static void sort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {//出口
            int mid = (left + right)/2;
            sort(arr, left, mid, temp);//向左递归
            sort(arr, mid + 1, right, temp);//向右递归
            merge(arr, left, mid, right, temp);
            System.out.println(Arrays.toString(arr));
        }
    }
    /*** @param arr 待排序数组
     * * @param left 左边有序数列的初始索引
     * * @param mid 中间索引
     * * @param right 右边索引
     * * @param temp 合并空间
     * */
    public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        System.out.println("调用:");
        int i = left;//i 左边有序序列的初始索引
        int j = mid + 1;//j 右边的有序序列的初始索引
        int t = 0;//指向当前位置的temp索引
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[t] = arr[i];
                i++;
                t++;
            } else {
                temp[t] = arr[j];
                t++;
                j++;
            }
        }
        while (i <= mid) {
            temp[t] = arr[i];
            i++;
            t++;
        }
        while (j <= right) {
            temp[t] = arr[j];
            t++;
            j++;
        }
        t = 0;
        int tmpLeft = left;
        while (tmpLeft <= right) {
            arr[tmpLeft] = temp[t];
            t++;
            tmpLeft++;
        }
    }
}

基数排序：

• 动态图：

• 代码实现：

package 数据结构.排序;

import java.util.Arrays;

public class 基数排序 {
    public static void sort(int[] arr){
        //找出最大的那个数；
        int max = arr[0];
        for(int i = 1;i<arr.length;i++){
            if(arr[i]>max){
                max = arr[i];
            }
        }
        //创建10个桶，二维数组；
        int[][] a = new int[10][arr.length];
//        创建数组b用来记录每个桶中元素的个数；
        int[] b = new int[10];
        //按照每个位把数组里的整数放在k相应桶里面；
        for (int k = 0,n = 1; k < (max + "").length(); k++, n = n * 10) {
            for (int i = 0; i < arr.length; i++) {
                //取每个位上的数：
                int digitofment = arr[i] / n % 10;
                //放在相应的桶里面；//0123456789
                a[digitofment][b[digitofment]] = arr[i];
                b[digitofment]++;//记录每个桶里面的元素的个数
            }
            //从桶里面取出来
            int index = 0;//arr数组的下标
            for (int i = 0; i < 10; i++) {
                if (b[i] != 0) {//桶里面有元素
                    for (int j = 0; j < b[i]; j++) {
                        arr[index] = a[i][j];
//                        a[i][j] = 0;没有必要，只要控制在这个桶的记得个数就可以了
                        index++;
                    }
                }
                b[i] = 0;//放回去后每个桶的元素归零；
            }
            System.out.println("排完顺序后是：" + Arrays.toString(arr));
        }
    }


    public static void main(String[] args) {
        int[] a = {122, 5666, 888, 999, 666, 4, 555, 25, 62, 555, 522, 6, 6,};
        sort(a);
    }
}

堆排序（树）：

• 动态图：

• 第一种：起始元素的下标是1：

package 数据结构.排序.堆排序;

import java.util.Arrays;

public class 堆排序 {
    /*
    *本质是以k为根的子树的根在不断的比较！！！
    * k的左孩子节点是2*k;
    * */
    //实现以k为根子树成为大根堆,前提是其子树都是大根堆。
    public static void Headadjust(int a[],int k,int len){
        a[0] = a[k];
        for (int i = 2*k; i <= len; i=i*2) {//左孩子下标
            if(i<len&&a[i]<a[i+1]){
                i++;
            }
            if(a[0]>=a[i]){//比左右孩子都要大==》大根堆
                break;
            } else{//说明需要交换
                a[k] = a[i];
                k = i;
            }
        }
//        for循环结束的两种情况：一是i>len;
//        二是以k为根的子树大于左右孩子
        a[k] = a[0];
    }
    //    建立大根堆：
    /*
     *二叉树的第一个下标是从1开始的
     * i代表所有的非叶子节点的下标
     * len代表二叉树的长度
     * */
    public static void BuildMaxHeap(int a[],int len){
        for (int i = len/2;i>0; i--) {
            Headadjust(a, i, len);
//            从最小的数开始，自下而上，保证子树都是大根堆；
        }
    }
    //实现堆排序
    public static void paixv(int a[],int len){
//        for(int i = 1;i<len;i++){//只需要保证n-1次循环就可以
//            BuildMaxHeap(a, len-(i-1));
//            int temp = a[len-(i-1)];
//            a[len-(i-1)] = a[1];
//            a[1] = temp;
//            for (int j = 1; j <=len; j++) {
//                System.out.print(a[j]+"\t");
//            }
//            System.out.println();
//        }
        BuildMaxHeap(a, len);//建立大根堆
        for (int i = 1; i < len; i++) {
            int temp = a[len-(i-1)];
            a[len-(i-1)] = a[1];
            a[1] = temp;
            Headadjust(a, 1, len-i);//1的子树都是大根堆。
            for (int j = 1; j <=len; j++) {
                System.out.print(a[j]+"\t");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        int[] a = new int[20];
        a[1] = 19 ;
        a[2] = 20 ;
        a[3] = 30 ;
        a[4] = 15 ;
        a[5] = 28 ;
        a[6] = 26 ;
        a[7] = 60 ;
        a[8] = 80 ;
        a[9] = 40 ;
        a[10] =10 ;
        paixv(a,10);
    }
}

• 第二种：起始元素的小标是0：差不多~