java相关总结4--冒泡、选择、快速、插入排序

网上很多例子，加深印象，方便查找，特记录。

main函数：

public static void main (String[] args) {
        //insertSort();//插入排序
        //bubbleSort(); //冒泡排序
        //selectSort();//选择排序
        int[] data = new int[]{3,6,22,1,33,5,99,-1};
        //quickSort(data, 0, data.length-1);//快速排序
        ninePlusNine();
        Set set = new HashSet();
        
    }

/**
     * 直接插入排序法
     */
    public static void insertSort(){      
        //int a[]={38,49,3,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
        int a[]={3,38,49,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
        int temp=0;     
        for(int i=1;i<a.length;i++){         
            int j=i-1;         
            temp=a[i];         //76
            // 将大于temp的值整体后移一个单位
            for(;j>=0&&temp<a[j];j--){         
                a[j+1]=a[j];     //3 38 49 97 97,3 38 49 49 97 ，3 38 38 49 97,3 13 38 49 97               
            }
            a[j+1]=temp;
        }
    
     for(int i=0;i<a.length;i++) {
         System.out.println(a[i]);
     }
    }
    //例如：3 2 5 4 1 这几个数字排序过程如下
    //3 2 5 4 1
    //2 3 5 4 1
    //2 3 5 4 1
    //2 3 5 5 1  4 为 temp变量的值
    //2 3 4 5 1
    //2 3 4 5 5  1为temp变量的值
    //2 3 4 4 5  1
    //2 3 3 4 5  1
    //2 2 3 4 5  1
    //1 2 3 4 5  1

/**
     * 冒泡排序
     * 双层循环
     * 第一层遍历每一个元素，第二层在从该元素循环N-1次交换邻近元素顺序
     * 循环N次，时间复杂度o(n^2)，空间复杂度o(1)
     */
    public static void bubbleSort(){
        int a[] = new int[] {4,3,5,6,2,1};
        int m = 0;
        System.out.println("排序前：" );
        printArray(a);
        System.out.println();
        //冒泡排序
        for(int i=0; i<a.length; i++){
            for(int j=1; j<a.length; j++){
                if(a[j-1]>a[j]){
                    m = a[j-1];
                    a[j-1] = a[j];
                    a[j] = m;
                }
            }
            System.out.println("第" + (i+1) + "次排序后结果：");
            printArray(a);
            System.out.println();
        }
        //结束
        System.out.println("------------------");
        System.out.println("排序后：");
        printArray(a);
    }

/**
     * 选择排序
     * 保留最小索引放在首位，n^2次循环
     * @param a
     */
    public static void selectSort(){
        int a[] = new int[] {4,3,5,6,2,1};
        System.out.println("排序前：" );
        printArray(a);
        System.out.println();
        for(int i=0; i<a.length; i++){
            int minIndex = i;
            for(int j=i+1; j<a.length; j++){
                if(a[j]<a[minIndex]){
                    minIndex=j;
                }
            }
            if(minIndex!=i){
                swapArrayIndex(a, i, minIndex);
            }
            System.out.println("第" + (i+1) + "次排序后结果：");
            printArray(a);
            System.out.println();
        }
        //结束
        System.out.println("------------------");
        System.out.println("排序后：");
        printArray(a);
    }

/**
     * 快速排序
     * @param data
     * @param start
     * @param end
     */
    public static void quickSort(int[] data, int start, int end) {
        if (start >= end)
            return;
        // 以起始索引为分界点
        int pivot = data[start];
        int i = start + 1;
        int j = end;
        while (true) {
            while (i <= end && data[i] < pivot) {
                i++;
            }
            while (j > start && data[j] > pivot) {
                j--;
            }
            if (i < j) {
                swap(data, i, j);
            } else {
                break;
            }
        }
        // 交换 j和分界点的值
        swap(data, start, j);
        print(data);
        // 递归左子序列
        quickSort(data, start, j - 1);
        // 递归右子序列
        quickSort(data, j + 1, end);
    }

//以下为辅助方法

//打印辅助方法

public static void print(int[] data) {
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i] + "\t");
        }
        System.out.println();
    }
        
    
    //打印辅助方法
    private static void printArray(int[] a) {
        for(int z=0; z<a.length; z++){
            System.out.print(a[z]);
        }
    }

    //交换数组元素位置1
    public static void swap(int[] data, int i, int j) {
        if (i == j) {
            return;
        }
        data[i] = data[i] + data[j];
        data[j] = data[i] - data[j];
        data[i] = data[i] - data[j];
    }
    //交换数组元素位置2
    private static void swapArrayIndex(int[] a, int i, int minIndex) {
        int temp = a[minIndex];
        a[minIndex] = a [i];
        a[i] = temp;
    }