标签：index java temp int 冒泡排序 length leftindex array 排序

import java.util.Arrays;

public class Sort2 {
    public static void main(String args[]) {
        int[] array = new int[] { 3, 5, 1, 2, 7, 6, 4, 8, 7 };
//        selectSort(array);
        quickSort(array, 0, array.length - 1);
//        bubbleSort(array);
//        insertSort(array);
        System.out.println(Arrays.toString(array));
    }

    /**
     * 冒泡排序，升序 两两比较，较大的数往后面冒
     * 
     * @param array
     */
    public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                // 大数往后冒
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }

    /**
     * 选择排序，升序 寻找最小值然后交换
     * 
     * @param array
     */
    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int min = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[min] > array[j]) {
                    min = j;
                }
            }
            if (min != i) {
                int temp = array[i];
                array[i] = array[min];
                array[min] = temp;
            }
        }
    }

    /**
     * 插入排序 将数组分为[0,index-1]的有序数列和[index,array.length]无序数列两部分 
     * 提取array[index]的值记为temp，准备插入左侧有序数列
     * 之后从有序数列右侧开始遍历，全体向右偏移一位，直至找到合适的插入点
     * 参考https://blog.csdn.net/qq_42857603/article/details/81605124
     * 
     * @param array
     */
    public static void insertSort(int[] array) {
        for (int index = 1; index < array.length; index++) {
            //temp为要插入到左侧的数
            int temp = array[index];
            int leftindex = index - 1;
            // 大数往后移动
            while (leftindex >= 0 && array[leftindex] > temp) {
                array[leftindex + 1] = array[leftindex];
                leftindex--;
            }
            array[leftindex + 1] = temp;
        }
    }
    /**
     * 快速排序
     * 参考https://blog.csdn.net/shujuelin/article/details/82423852
     * 
     * @param array
     * @param low
     * @param high
     */
    public static void quickSort(int[] array, int low, int high) {
        if (low > high) {
            return;
        }
        int i = low;
        int j = high;
        int base = array[low];
        while (i < j) {
            // 先看右边，找到第一个小于基准点的数
            while (i < j && array[j] >= base) {
                j--;
            }
            // 再看左边，找一个大于基准点的数
            while (i < j && array[i] <= base) {
                i++;
            }
            if (i < j) {
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;

            }
        }
        // 最后将基准位与i和j相等位置的数字交换
        array[low] = array[i];
        array[i] = base;
        //递归调用排序左侧
        quickSort(array, low, i - 1);
        //递归调用排序右侧
        quickSort(array, i + 1, high);
    }

}

标签：index,java,temp,int,冒泡排序,length,leftindex,array,排序
来源： https://www.cnblogs.com/lz-0011/p/10890644.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。