基本排序算法（java）

public class Aa {

    public static void main(String[] args) throws Exception {

        int[] arr = new int[100000];
        for (int i = 0; i < 100000; i++) {
            arr[i] = (int) (Math.random() * 100000);
        }

        System.out.println(System.currentTimeMillis());

        Quick bu = new Quick();
        bu.sort(arr, 0, arr.length - 1);
        System.out.println(System.currentTimeMillis());


        for (int kk : arr) {
            System.out.println(kk);
        }


        System.out.println("==============");

        int[] brr = {48, -98, 39, 29, 72, -76, 13};
        Select se = new Select();
        se.sort(brr);

        for (int b : brr
                ) {
            System.out.println(b);

        }

        int[] insertArr = {58, -89, 135, 24, -4, 59, 73, 65};
        Insert insert = new Insert();
        insert.sort(insertArr);
        for (int in : insertArr
                ) {
            System.out.println(in);
        }

        int[] quickArr = {2, 6, 7, 3, 3, 3, 1, 3, 8, 24};
        Quick quick = new Quick();
        quick.sort(quickArr, 0, quickArr.length - 1);

        for (int qu : quickArr
                ) {
            System.out.println(qu);
        }

    }


}


class Bubble {
    public void sort(int[] arr) {
        int temp;
        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]) {
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
}

class Select {
    public void sort(int[] arr) {
        int temp;
        for (int i = 0; i < arr.length - 1; i++) {
            int min = arr[i];
            int minIndex = i;

            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {
                    min = arr[j];
                    minIndex = j;

                }
            }

            temp = arr[i];
            arr[i] = min;
            arr[minIndex] = temp;


        }
    }
}

class Insert {
    public void sort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int insertVal = arr[i];
            int insertIndex = i - 1;
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            arr[insertIndex + 1] = insertVal;
        }
    }
}

class Quick {
    public void sort(int[] arr, int low, int high) {
        if (low >= high) {
            return;
        }

        int l = low;
        int h = high;

        int pivot = arr[(low + high) / 2];
        int temp = 0;

        while (l < h) {
            while (arr[l] < pivot) {
                l++;
            }

            while (arr[h] > pivot) {
                h--;
            }

            if (l >= h) {
                break;
            }


            temp = arr[l];
            arr[l] = arr[h];
            arr[h] = temp;

            if (arr[l] == pivot) {
                h--;
            }

            if (arr[h] == pivot) {
                l++;
            }


        }

        if (l == h) {
            l++;
            h--;
        }

        if (low < h) {
            sort(arr, low, h);
        }
        if (high > l) {
            sort(arr, l, high);
        }


    }
}



class Quick2{
     public void sort(int[] a,int low,int high){
        int i,j,index;
        if (low >= high) {
            return;
        }
        
        i = low;
        j = high;
        index = a[i];
        // 用子表的第一个记录做基准
        while (i < j) {
            // 从表的两端交替向中间扫描
            while (i < j && a[j] >= index) {
                j--;
            }
            if (i < j) {
                a[i++] = a[j];
                // 用比基准小的记录替换低位记录
            }
            while (i < j && a[i] < index) {
                i++;
            }
            if (i < j) { 
                // 用比基准大的记录替换高位记录
                a[j--] = a[i];
            }
        }
        a[i] = index;
        // 将基准数值替换回 a[i]
        sort(a, low, i - 1);
        // 对低子表进行递归排序
        sort(a, i + 1, high);
        // 对高子表进行递归排序
    }
    
}


import java.util.Arrays;

public class Merge {
    private static Integer[] aux; // auxiliary array for merges

    public static void sort(Integer[] a) {
        aux = new Integer[a.length]; // Allocate space just once.
        sort(a, 0, a.length - 1);
    }

    private static void sort(Integer[] a, int lo, int hi) { // Sort a[lo..hi].
        if (hi <= lo) {
            return;
        }
        int mid = lo + (hi - lo) / 2;
        sort(a, lo, mid); // Sort left half.
        sort(a, mid + 1, hi); // Sort right half.
        merge(a, lo, mid, hi); // Merge results
    }

    public static void merge(Integer[] a, int lo, int mid, int hi) { // Merge a[lo..mid] with a[mid+1..hi].
        int i = lo, j = mid + 1;
        // Copy a[lo..hi] to aux[lo..hi].
        for (int k = lo; k <= hi; k++) {
            aux[k] = a[k];
        }

        // Merge back to a[lo..hi].
        for (int k = lo; k <= hi; k++) {
            if (i > mid) {
                a[k] = aux[j++];
            } else if (j > hi) {
                a[k] = aux[i++];
            } else if (aux[j] < aux[i]) {
                a[k] = aux[j++];
            } else {
                a[k] = aux[i++];
            }
        }

    }

    public static void main(String[] args) {
        Integer[] integers = {-56, 1, 36, 94, 29, -21, 108, 77};
        sort(integers);
        System.out.println(Arrays.toString(integers));
    }
}




-----------------------------------------

public static void bucketSort(int[] arr){
    
    // 计算最大值与最小值
    int max = Integer.MIN_VALUE;
    int min = Integer.MAX_VALUE;
    for(int i = 0; i < arr.length; i++){
        max = Math.max(max, arr[i]);
        min = Math.min(min, arr[i]);
    }
    
    // 计算桶的数量
    int bucketNum = (max - min) / arr.length + 1;
    ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
    for(int i = 0; i < bucketNum; i++){
        bucketArr.add(new ArrayList<Integer>());
    }
    
    // 将每个元素放入桶
    for(int i = 0; i < arr.length; i++){
        int num = (arr[i] - min) / (arr.length);
        bucketArr.get(num).add(arr[i]);
    }
    
    // 对每个桶进行排序
    for(int i = 0; i < bucketArr.size(); i++){
        Collections.sort(bucketArr.get(i));
    }
    
    // 将桶中的元素赋值到原序列
	int index = 0;
	for(int i = 0; i < bucketArr.size(); i++){
		for(int j = 0; j < bucketArr.get(i).size(); j++){
			arr[index++] = bucketArr.get(i).get(j);
		}
	}  
}