八大排序

冒泡排序

    public static void bubbleSort(int[] array) {
        int length = array.length;

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

 

插入排序

    public static int[] sort(int[] array) {

        for (int i = 1; i < array.length; i++) {
            for (int j = i; j > 0; j--) {
                System.out.println(array[j] + " " + array[j - 1]);
                if (array[j] < array[j - 1]) {
                    int temp = array[j];
                    array[j] = array[j - 1];
                    array[j - 1] = temp;
                }
            }

        }


        return array;
    }

 

交换排序

    public static int[] sort(int[] array){

        // 用来向后移动 交换之后就进行++操作
        int index = 0;

        for (int i = 0; i < array.length; i++) {
            index = i;
//            index = 0;
            // 找出最小的一个值
            for (int j = i; j < array.length; j++) {

                if(array[j] <= array[index]){
                    index = j;
                }
            }

            // 寻找完毕之后开始进行交换
            int temp = array[index];
            array[index] = array[i];
            array[i] = temp;

        }

        return array;
    }

 

归并排序

public class MergeSort {
    public static void main(String[] args) {
        int[] array = {8, 4, 5, 7, 1, 3, 6, 2};
        int[] index = {0, 1, 2, 3, 4, 5, 6, 7};
        int[] temp = new int[array.length];
        System.out.println("indexx" + Arrays.toString(index));
        System.out.println("origin" + Arrays.toString(array));
        mergeSort2(array, 0, array.length - 1, temp);
        System.out.println(Arrays.toString(array));
    }


    /**
     * 该方法实现分加合
     *
     * @param array 待排序数组
     * @param left  左边索引
     * @param right 右边索引
     * @param temp  临时数组   为了进行数据拷贝
     */
    public static void mergeSort(int[] array, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2;
            System.out.println(" left = "+ left +" right = " + right + " mid = " + mid);


            // 向左进行分解

            mergeSort(array, left, mid, temp);
            // 向右进行分解
            mergeSort(array, mid + 1, right, temp);
            // 合并
            merge(array, left, mid, right, temp);
        }
    }

    /**
     * 该方法实现将数组进行合并
     *
     * @param array 待排序数组
     * @param left  左边界的初始值 0
     * @param mid   中间值
     * @param right 有边界初始值 length - 1
     * @param temp  中转让数组
     */
    public static void merge(int[] array, int left, int mid, int right, int[] temp) {
        int i = left; // 左边的索引
        int j = mid + 1; // 右边的索引
        int t = 0;  // 临时数组的索引


        // 排序过程
        while (i <= mid && j <= right) {

            // 将分好的数组拷贝到临时数组中
            if (array[i] <= array[j]) {
                temp[t] = array[i];
                t += 1;
                i += 1;
            } else {
                temp[t] = array[j];
                t += 1;
                j += 1;
            }
        }
//        System.out.println("xxxxxx" + Arrays.toString(temp));

        // 将左边或者右边剩下的数据拷贝到temp数组中
        while (i <= mid) {
            temp[t] = array[i];
            t += 1;
            i += 1;
        }
        while (j <= right) {
            temp[t] = array[j];
            t += 1;
            j += 1;
        }


        // 将temp中的数组拷贝到原数组
        t = 0;
        int tempLeft = left;
        while (tempLeft <= right) {
            array[tempLeft] = temp[t];
            t += 1;
            tempLeft += 1;
        }


    }


    public static void mergeSort2(int[] array, int left ,int right, int[] temp){
        if(left < right){
            int mid = (left + right) / 2;
            mergeSort2(array,left,mid,temp);
            mergeSort2(array,mid + 1,right,temp);
            merge2(array,left,mid, right,temp);
        }
    }

    public static void merge2(int[] array, int left , int mid, int right ,int[] temp){

        int l = left; // 0
        int r = mid + 1; // mid + 1
        int t = 0;

        while (l <= mid && r <= right) {
            if(array[l] <= array[r]){
                temp[t] = array[l];
                t+=1;
                l+=1;
            } else{
                temp[t] = array[r];
                t+=1;
                r+=1;
            }
        }

        // 如果有剩余
        while (r <= right) {
            temp[t] = array[r];
            t+=1;
            r+=1;
        }

        while (l <= mid) {
            temp[t] = array[l];
            t+=1;
            l+=1;
        }

        t = 0;
        int tempLeft = left;
        while (tempLeft <= right) {
            array[tempLeft] = temp[t];
            tempLeft += 1;
            t += 1;
        }
    }


}

 

快速排序

    public static void quickSort(int[] array, int left, int right){
        int r = right;
        int l = left;
        int temp = 0; //临时变量 用于两个数交换
        int p = (r + l) / 2; // 中值
        int pivot = array[p];
        while (l < r) {
            // 在左边 找一个大于pivot的数
            while (array[l] < pivot){
                l += 1;
            }
            // 在右边 找一个小于中值数的数 小于等于就退出循环
            while (array[r] > pivot){
                r -= 1;
                System.out.println("r = " + r);
            }

            System.out.println(Arrays.toString(array) + " left = " + l + " right = " + r + " array[middle] = " + pivot + " middle = " + p);

            // 进行交换
            temp = array[r];
            array[r] = array[l];
            array[l] = temp;




            // 如果向右移动遇到了pivot 就向前加一个
            if(array[l] == pivot){
                l += 1;
            }

            // 如果向左移动遇到了pivot， 就向后移动一个位置
            if(array[r] == pivot){
                r -= 1;
            }


            // 向右递归
            if(l < right){
                quickSort(array,l, right);
            }

            // 向左递归
            if(r > left ){
                quickSort(array,left,r);
            }

            // 防止栈溢出
            if(r == l){
                r--;
                l++;
            }
        }
    }

 

基数排序

    public static void sort(int[] array) {
        int[][] bucket = new int[10][array.length];
        int[] index = new int[10];

        // 获取字符串长度
        int length = getLength(max(array));


        for (int i = 0; i < length; i++) {
            // 计算模值
            int pow = pow(10, i);

            // 遍历原数组放入桶中
            for (int j = 0; j < array.length; j++) {
                int base = array[j] / pow % 10;
                bucket[base][index[base]] = array[j];
                index[base]++;
            }

            // 同中取出放回原数组中
            int h = 0;
            for (int j = 0; j < 10; j++) {

                for (int k = 0; k < bucket[j].length; k++) {

                    if (bucket[j][k] != 0) {
                        array[h++] = bucket[j][k];
                    }
                }
            }

            // 清空筒子
            for (int j = 0; j < bucket.length; j++) {
                Arrays.fill(bucket[j], 0);
            }
        }
    }

 

希尔排序（移位和交换）

    // 希尔排序  交换法
    // 设定一个步长 每次排序都使用这个步长
    public static void shellSort(int[] array) {

        // i 是步长每次/2
        for (int gap = array.length / 2; gap > 0; gap /= 2) {
            // 根据每次的gap进行一轮排序
            for (int i = gap; i < array.length; i++) {
                // 具体的排序过程 向左排一半
                for (int j = i - gap; j >= 0; j -= gap) {
                    if(array[j] >= array[j + gap]) {
                        int temp = array[j];
                        array[j] = array[j + gap];
                        array[j + gap] = temp;
                    }
                }
            }
        }
        // 分组
        for (int gap = array.length / 2; gap > 0; gap /= 2) {
            // 排序的数量
            for (int i = gap; i < array.length; i++) {
                // 判断是否交换
                for (int j = 0; j < array.length - gap; j += gap) {
                    if (array[j] >= array[j + gap]) {
                        int temp = array[j];
                        array[j] = array[j + gap];
                        array[j + gap] = temp;
                    }
                }
            }
        }
    }

    // 移位法希尔排序
    public static void shellSort2(int[] array) {
        // 先进行分组确定步长
        for (int gap = array.length / 2; gap > 0; gap /= 2) {
            // 从步长开始向后移动
//            System.out.println("gap = " + gap );
//            System.out.println(Arrays.toString(new int[] {0,1,2,3,4,5,6,7,8,9}));
            for (int i = gap; i < array.length; i++) {
                // 确定插入位置的指针
                int j = i;
                int temp = array[j];
                if (array[j] < array[j - gap]) {
                    while (j - gap >= 0 && temp < array[j - gap]) {
//                        System.out.println("array[j] = " + array[j] + " array[j-gap] = " +  array[j - gap]);
                        array[j] = array[j - gap];
//                        System.out.println("j = " + j + " j - gap = " + (j - gap));
                        System.out.println("移动位置"+Arrays.toString(array));
                        j -= gap;
                    }

                    // 退出while表示找到对应的插入位置了
                    array[j] = temp;
                    System.out.println("找到位置"+Arrays.toString(array));
                }
            }
            System.out.println();
        }



    }