java数组排序算法01-冒泡，选择，希尔排序，插入排序

java数组排序算法

冒泡排序

原理：数组元素两两比较，交换位置，大元素往后放，经过一轮比较后，最大的元素，就会出现在最大索引处。

O(n^2)

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {1,34,23,3,45,6};
        int[] arr2 = bubble(arr);
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i]+"\t");
        }
    }
    public static int[] bubble(int[] arr){
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            boolean flag = false;
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }
            }
            if (flag == false){
                break;
            }
        }
        return arr;
    }
}

选择排序

原理：从0索引处开始，一次和后面的元素进行比较，小的元素往前放，经过一轮比较后，最小的元素就出现在了最小索引处。

O(n^2)

import java.util.Arrays;

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {1,34,23,3,45,6,2,34,6,7};
        int[] arr2 = select(arr);
        System.out.println(Arrays.toString(arr2));
        }

    private static int[] select(int[] arr) {
        int temp = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if(arr[i] > arr[j]){
                    temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }
}

插入排序

原理：直接插入排序，将一个记录插入到一个长度为m的有序表中，使之仍保持有序

O(n^2)

public class DirectInsert {
    public static void main(String[] args) {
        int[] arr = {1,34,23,3,45,6,2,34,6,7};
        int[] arr2 = insert(arr);
        System.out.println(Arrays.toString(arr2));
    }
    public static int[] insert(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            int j = i;
            while(j>0 && arr[j]<arr[j-1]){
                int tmp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = tmp;
                j--;
            }
        }
      // second way
        for (int i = 0; i < arr.length; i++) {
            for (int j = i; j > 0; j--) {
                if(arr[j]<arr[j-1]){
                    int tmp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = tmp;
                }
            }
        }
        return arr;
    }
}

希尔排序

又名缩小增量排序，对插入排序的优化

原理：先将原表按照增量ht分组，每个字文件按照直接插入法排序。同样，用下一个增量ht/2将文件再分为子文件，再直接插入法排序，直到ht=1时整个文件排好顺序

关键为选择合适的增量

一般选择为数组长度的一半，但仍然不是很高效，可以使用克努特序列来选择增量
h = 1
h = 3*h + 1

import java.util.Arrays;

public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {1,34,23,3,45,6,2,34,6,7,-1,-20};
        int[] arr2 = shell(arr);
        System.out.println(Arrays.toString(arr2));
    }

    private static int[] shell(int[] arr) {
      // use 1/2 length of arr  
      int h = arr.length/2;
        for (int i1 = h; i1 > 0; i1/=2) {
            for (int i = i1; i < arr.length; i++) {
                for (int j = i; j > i1-1; j-=i1) {
                    if(arr[j]<arr[j-i1]){
                        swap(arr,j,j-i1);
                     }
                }
            }
        }
      
       // 克努特序列
        int interval = 1;
        while(interval <= arr.length/3){
            interval = interval*3+1;
        }
        for (int i1 = interval; i1 > 0; i1 = (i1-1)/3) {
            for (int i = i1; i < arr.length; i++) {
                for (int j = i; j > i1-1; j-=i1) {
                    if(arr[j]<arr[j-i1]){
                        swap(arr,j,j-i1);
                    }
                }
            }
        }
      
        return arr;
    }
    public static void swap(int[] arr,int i, int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}