快速排序，选择排序，冒泡排序，插入排序

import java.util.Arrays;

public class sort {
    public static void main(String[] args){
        int[] array = {1,5,6,2,7,3,9};
//        QuickSort quickSort = new QuickSort();
//        try {
//            int[] res = quickSort.sort(array);
//            for(int i=0;i<res.length;i++){
//                System.out.println(res[i]);
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }

//        selectionSort(array);
          insertSort(array);
//        bubbleSort(array);
    }

    //选择排序：从左到右，找出最小的放在最左

//    首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
//    再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
//    重复第二步，直到所有元素均排序完毕。
    public static void selectionSort(int[] array){
        int[] arr = Arrays.copyOf(array,array.length);
        // 总共要经过 N-1 轮比较
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;

            // 每轮需要比较的次数 N-i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    // 记录目前能找到的最小值元素的下标
                    min = j;
                }
            }

            // 将找到的最小值和i位置所在的值进行交换
            if (i != min) {
                int tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }
        }
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }

    //插入算法：从右到左（左为有序，右为无序），对比有序区，

    // 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
    // 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。
    // （如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。)
    public static void insertSort(int[] array){
        int[] arr = Arrays.copyOf(array,array.length);
        // 从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
        for (int i = 1; i < arr.length; i++) {

            // 记录要插入的数据
            int tmp = arr[i];

            // 从已经排序的序列最右边的开始比较，找到比其小的数
            int j = i;
            while (j > 0 && tmp < arr[j - 1]) {
                arr[j] = arr[j - 1];
                j--;
            }
//            for(;j>0;j--){
//                if(tmp < arr[j-1]){
//                    arr[j] = arr[j-1];
//                }else{
//                    break;
//                }
//            }

            // 存在比其小的数，插入
            if (j != i) {
                arr[j] = tmp;
            }
        }
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }

    //冒泡排序:从左到右，两两进行比比较
    /*
    * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
    *对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
    *针对所有的元素重复以上的步骤，除了最后一个。
    *持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
    * */
    public static void bubbleSort(int[] array){
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(array, array.length);
        int n =0;

        for (int i = 1; i < arr.length; i++) {
            // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
            boolean flag = true;

            for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;

                    flag = false;
                }
            }

            if (flag) {
                break;
            }
            n++;
        }
        System.out.println(n);
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

    }


}