排序算法 冒泡 选择 插入 shell 快速 归并排序

1. 冒泡排序

for (int i = 0;i < arr.length;i++){冒泡排序//将最大元素放到最后面
            for (int j = 0;j < arr.length - i - 1;j++){
                if (arr[j] > arr[j + 1]){
                    int t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }
        }
System.out.println(Arrays.toString(arr));

2. 选择排序

for (int i = 0;i < arr.length;i++){选择排序//找出每一次的最小元素
        for (int j = i;j < arr.length - 1;j++){
        	if (arr[i] > arr[j + 1]){
       		 int t = arr[i];
        	arr[i] = arr[j + 1];
        	arr[j + 1] = t;
        }
    }
   System.out.println(Arrays.toString(arr));
 }

3. 插入排序

for (int i = 0; i < arr.length - 1; i++) {//插入排序
            for (int j = i;j >= 0;j--){
                if (arr[j] > arr[j + 1]){
                    int t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
            }
       }
       System.out.println(Arrays.toString(arr));
 }

4. shell排序（希尔排序）

for (int h = arr.length / 2; h > 0; h /= 2) {//shell排序
            for (int i = h; i < arr.length; i++) {
                for (int j = i; j > h - 1; j -= h) {
                    if (arr[j] < arr[j - h]) {
                        int t = arr[j];
                        arr[j] = arr[j - h];
                        arr[j - h] = t;
                 }
             }
        }
       System.out.println(Arrays.toString(arr));
}

5. 快速排序

private static void sort(int[] arr, int start, int end) {//快速排序
        if (start > end){
            return;
        }else {
            int index = QuickSort(arr,start,end);
            sort(arr,start,index - 1);
            sort(arr,index + 1,end);
        }
    }
private static int QuickSort(int[] arr,int start,int end){
        int key = arr[start];
        while (start < end){
            while (start < end && arr[end] >= key){
                end --;
            }
            arr[start] = arr[end];
            while (start < end && arr[start] <= key){
                start++;
            }
            arr[end] = arr [start];
        }
        arr[end] = key;
        return end;
}

6. 归并排序

 public static void mergeSort(int[] arr, int left, int right) {
            if (left >= right) {
                return ;
            }
            int mid = (left + right) / 2;
            mergeSort(arr, left, mid);
            mergeSort(arr, mid + 1, right);
            merge(arr,left,mid,mid + 1,right);
            //System.out.println(Arrays.toString(arr));
        }
public static void merge(int[] arr, int leftStart, int leftEnd, int rightStart, int rightEnd) {//归并排序
            int i = leftStart;
            int j = rightStart;
            int k = 0;
            int[] temp = new int[rightEnd - leftStart + 1];
            while (i <= leftEnd && j <= rightEnd) {
                if (arr[i] > arr[j]) {
                    temp[k++] = arr[j++];
                } else {
                    temp[k++] = arr[i++];
                }
            }
            while (i <= leftEnd) {
                temp[k++] = arr[i++];
            }
            while (j <= rightEnd) {
                temp[k++] = arr[j++];
            }
            k = leftStart;
            for (int v:temp){
                arr[k++] = v;
            }
}