关于排序的问题

冒泡排序

    public static void bubbleSort(int[] array) {
        //冒泡排序
        //按照每次找最小进行排序（从后往前交换）
        for (int bound=0;bound< array.length;bound++){
            //[0,bound)已排序区间；[bound,size)已排序区间
            for (int cur= array.length-1;cur>bound;cur--){
                //如果cur+1有可能越界
                if(array[cur-1]>array[cur]){
                    swap(array,cur-1,cur);
                }
            }
        }
    }
    private static void swap(int[] array,int i,int j){
        int tmp=array[i];
        array[i]=array[j];
        array[j]=tmp;
    }

快速排序：分别采用递归与非递归

//快速排序
    //1）待排区间，找到一个基准值（常见取第一个或最后一个元素）
    //2）以基准为中心，把整个区间整理为三个部分，左侧部分元素丢小于基准值，右侧部分元素丢大于基准值，
    //3）在针对左侧、右侧整理好的区间，进一步递归，重复刚才的整理过程
    public static void quickSort(int[] array){
        //辅助完成递归
        quickSortHelper(array,0,array.length-1);
    }

    private static void quickSortHelper(int[] array,int left,int right) {
        if(left>=right){
            return;
        }
        //针对[left,right]区间进行整理
        int index=partition(array,left,right);
        //index返回值就是整理完毕后left与right重合位置，知道这个位置才能进行递归
        quickSortHelper(array,left,index-1);
        quickSortHelper(array,index+1,right);
    }

    private static int partition(int[] array, int left, int right) {
        int i=left;
        int j=right;
        int base=array[right];//基准值

        while (i<j){
            //从左往右找到比基准值大的元素
            while (i<j&&array[i]<=base){
                i++;
            }
            //当上面循环结束时，此时i与j重合或i指向大于base的值
            //从右往左找比基准值小的元素
            while (i<j&&array[j]>=base){
                j--;
            }
            //上面循环结束后，i与j重合或j指向小于base的值
            //交换i和j的值
            swap(i,j);
        }
        //当i和j重合的时候，最后一步，要把重合位置的元素和基准值进行交换
        swap(array,i,right);
        return i;
    }

    private static void swap(int i,int j){
        int tmp=i;
        i=j;
        j=tmp;
    }
    private static void swap(int[] array,int i,int j){
        int tmp=array[i];
        array[i]=array[j];
        array[j]=tmp;
    }

    //不使用递归的快速排序
    public static void quickSortByLoop(int[] array){
        //借助栈
        Stack<Integer> stack=new Stack<>();
        //stack用来存放数组下标，通过下标来表示接下来要处理的区间
        //初始情况下，先把右侧边界下标入栈，再把左侧边界下标入栈，左右边界仍然构成前闭后闭区间
        stack.push(array.length-1);
        stack.push(0);

        while (!stack.isEmpty()){
            int left=stack.pop();
            int right=stack.pop();
            //这个代码取元素顺序与oush顺序正好相反
            if(left>=right){
                continue;
            }

            //通过partition把区间整理成以基准值为中心，左侧<=基准，右侧>=jiz
            int index=partition(array,left,right);
            //准备处理下个区间
            stack.push(right);
            stack.push(index+1);

            stack.push(index-1);
            stack.push(left);
        }
    }