七个排序算法总结(Java实现)

//冒泡
    public static void bubbleSort(int[] arr){
        int temp =  0;
        boolean flag  = false;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j]>arr[j+1]){
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            if (!flag){
                break;
            }
            flag = false;
        }
    }


    //选择
    public static void selectSort(int[] arr){
        int min = 0;
        int minIndex = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            min = arr[i];
            minIndex = i;
            for (int j = i+1; j < arr.length; j++) {
                if (min > arr[j]){
                    min = arr[j];
                    minIndex = j;
                }
            }
            if (minIndex!= i){
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
        }
    }


    //插入
    public static void insertSort(int[] arr){
        int index = 0;
        int val;
        for (int i = 1; i < arr.length; i++) {
            val = arr[i];
            index = i;
            while (index - 1 >= 0 && val < arr[index - 1]){
                arr[index] = arr[index - 1];
                index--;
            }
            arr[index] = val;
        }
    }

    //希尔排序
    public static void shellSort(int[] arr ){
        int val;
        int index;
        for (int gap = arr.length/2; gap >0 ; gap/= 2) {
            for (int i = gap; i < arr.length; i++) {
                val = arr[i];
                index = i;
                while (index - gap >= 0 && val < arr[index - gap]){
                    arr[index]= arr[index - gap];
                    index --;
                }
                arr[index] = val;
            }
        }
    }

    //快速排序
    public static void quickSort(int[] arr,int left ,int right){
        if (left >= right){
            return;
        }
        int l = left;
        int r = right;
        int pivot = arr[left];
        int temp;
        while (l < r){
            while (l < r && arr[r] >= pivot){
                r--;
            }
            while (l< r && arr[l] <= pivot){
                l++;
            }
            if (l < r){
                temp = arr[l];
                arr[l] = arr[r];
                arr[r] = temp;
            }
        }
        arr[left] = arr[l];
        arr[l] = pivot;

        quickSort(arr,left,l -1);
        quickSort(arr,l+ 1,right);

    }

    //归并排序
    public static void merge(int[] arr ,int left,int mid,int right,int[] temp ){
        int l = left;
        int r = mid +1;
        int t = 0;
        while (l <= mid && r <= right){
            if (arr[l] < arr[r]){
                temp[t] = arr[l];
                t++;l++;
            }else {
                temp[t] = arr[r];
                t++;r++;
            }
        }
        while (l <= mid){
            temp[t] = arr[l];
            t++;l++;
        }
        while (r <= right){
            temp[t] = arr[r];
            t++;r++;
        }
        t = 0;
        for (int i = left; i <=right ; i++) {
            arr[i] = temp[t];
            t++;
        }
    }
    public static void mergeSort(int[] arr, int left , int right ,int [] temp){
        if(left < right){
            int mid = (left + right)/2;
            mergeSort(arr,left,mid,temp);
            mergeSort(arr,mid + 1,right,temp);
            //合并的前提是要合并的两个数组有序
            merge(arr,left,mid,right,temp);
        }
    }

    //基数排序
    public static void radixSort(int[] arr){
        int[][] bucket = new int[arr.length][arr.length];
        int[] eleCount = new int[arr.length];
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]){
                max = arr[i];
            }
        }
        int maxLength = (max + "").length();

        for (int i = 0,n = 1; i < maxLength; i++,n *= 10) {
            for (int j = 0; j < arr.length; j++) {
                int digit = arr[j]/n % 10;
                bucket[digit][eleCount[digit]] = digit;
                eleCount[digit]++;
            }
            int t = 0;
            for (int j = 0; j < eleCount.length; j++) {
                if (eleCount[j] != 0){
                    for (int k = 0; k < eleCount[j]; k++) {
                        arr[t] = bucket[j][k];
                        t++;
                    }
                }
                eleCount[j] = 0;
            }
        }
    }