常用的排序算法总结（java）

1. 冒泡排序

 public static void bubbleSort() {
        int[] numbers = {3, 12, 88, 43, 66, 4, 9, 1, 10};
        int i, j;
        for (i = 0; i < numbers.length - 1; i++) {
            for (j = 0; j < numbers.length - 1 - i; j++) {
                if (numbers[j] > numbers[j + 1]) {
                    int temp = numbers[j];
                    numbers[j] = numbers[j + 1];
                    numbers[j + 1] = temp;
                }
            }
        }
    }

说明：

• 比较相邻的两个元素，如果第一个比第二个大，就交换相应的位置（将较小的数放在前面，较大的数放在后面）
• 每进行一趟排序就会少比较一次（因为每趟排序都会找出一个最大值）

2. 选择排序

 public static void selectionSort() {
        int[] numbers = {3, 12, 88, 43, 66, 4, 9, 1, 10};
        int i, j;
        for (i = 0; i < numbers.length - 1; i++) {
            int minIndex = i;
            for (j = i + 1; j < numbers.length; j++) {
                if (numbers[j] < numbers[minIndex]) {//找到最小数
                    minIndex = j;//保存最小数索引
                }
            }
            if (minIndex != i) {
                int temp = numbers[minIndex];
                numbers[minIndex] = numbers[i];
                numbers[i] = temp;
            }
        }
    }

说明：

• 首先在未排序的序列中找到最小（大）的元素，放到已排序序列的起始位置
• 然后再从剩余的未排序序列中找出最小（大）元素，放在已排序序列的末尾，以此类推，直到所有元素排序完毕

3. 插入排序

public static void insertionSort() {
        int[] numbers = {3, 12, 88, 43, 66, 4, 9, 1, 10};
        int i, j, temp;
        /*
         * 第一个for循环
         * 把数组分成两部分，右边为未排序，左边为已排序
         * 记录排序与未排序分割点temp（temp为下一个排序对象）
         */
        for (i = 1; i < numbers.length; i++) {
            temp = numbers[i];
            /*
             * 第二个for循环
             * 将排序对象temp与已排序数组比较
             * 当temp比左边的数大时（按从小到大循序排列时）
             * 直接结束本次循环，进行下一个数排序
             * 否则比左边这个数小时，将左边这个数后移，腾出这个数的位置
             */
            for (j = i - 1; j >= 0; j--) {
                if (temp > numbers[j]) {
                    break;
                } else {
                    numbers[j + 1] = numbers[j];
                }
            }
            numbers[j + 1] = temp;
        }
    }

说明：

• 通过构建有序序列，对于未排序的数据，在已排序中从后向前扫描，找到相应位置并插入

4. 快速排序

   public static void quickSort(int[] arrays, int left, int right) {

        if (arrays.length < 1 || left < 0 || right >= arrays.length || left > right) return;

        int i, j, base, temp;
        i = left;
        j = right;
        base = arrays[left];

        while (i < j) {

            while (arrays[j] >= base && i < j) {
                   j--;
            }

            while (arrays[i] <= base && i < j) {
                   i++;
            }

            if (i < j) {
                temp = arrays[j];
                arrays[j] = arrays[i];
                arrays[i] = temp;
            }
        }

        arrays[left] = arrays[i];
        arrays[i] = base;

        quickSort(arrays, left, j - 1);
        quickSort(arrays, j + 1, right);
    }

说明：

• 首先在序列中选择一个基准点，然后分别从序列的两端进行扫描，先从后半部分开始，发现小于基准点的值就进行交换，然后从前半部分开始，发现有大于基准点的值就进行交换，直到后半部分的索引位置等于前办部分的索引位置结束
• 一次排序完成后，就采用递归的方式分别进行前半部分和后半部分的序列进行排序