Java 排序算法: 交换排序 (冒泡排序+快速排序)

内部排序的五大排序类型

1. 插入排序
2. 交换排序

• 冒泡排序
• 快速排序

3. 选择排序
4. 归并排序
5. 基数排序

冒泡排序(BubbleSort) 及其改进

冒泡排序规则:

1. 一共进行 [数组大小 -1] 次的大循环
2. 每一趟大循环的里的小循环(即每一趟)在逐渐的减少[开始也是 数组大小-1 次, 后依次减少循环至0结束]
3. 如果我们发现在某趟排序中, 没有发生过一次数据交换, 则可以提前结束, 这就是优化冒泡排序

代码实现:

package com.com.beyond.dhl.utils.sort;

import java.util.Arrays;

/**
 * 冒泡排序
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {1, 5, 3, 2, 6, 7, 0, -3};
        System.out.println("冒泡排序前:" + Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println("冒泡排序后:" + Arrays.toString(arr));
    }


    public static void bubbleSort(int[] arr) {
        int temp = 0;   // 辅助位置交换
        boolean flag = false;  // 优化判断标识

        for (int x = 0; x < arr.length - 1; x++) {
            for (int y = 0; y < arr.length - 1 - x; y++) {
                if (arr[y] > arr[y + 1]) {
                    flag = true;
                    temp = arr[y];
                    arr[y] = arr[y + 1];
                    arr[y + 1] = temp;
                }
            }
            if (!flag) {
                break;    // 如果没有一次交换数据, 则直接结束
            }
            flag = false;  // 标识重置
        }
    }
}

冒泡排序 测试80000个随机数据的排序效率

package com.com.beyond.dhl.utils.sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.Random;

/**
 * 冒泡排序
 */
public class BubbleSort {
    public static void main(String[] args) {
//        int[] arr = {1, 5, 3, 2, 6, 7, 0, -3};
//        System.out.println("冒泡排序前:" + Arrays.toString(arr));
//        bubbleSort(arr);
//        System.out.println("冒泡排序后:" + Arrays.toString(arr));


        int[] test = new int[80000];  // 测试数据
        for (int i = 0; i < test.length; i++) {
            test[i] = (int) (Math.random() * 1000000);  // 随机生成一个 [0,1000000) 数
        }

//        Date date = new Date();
//        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        System.out.println(dateFormat.format(date));

        long start = System.currentTimeMillis();
         bubbleSort(test);
        long end = System.currentTimeMillis();
        System.out.println("80000个随机数使用冒泡排序所耗时间为: " +(end - start) / 1000 + "秒");

    }


    public static void bubbleSort(int[] arr) {
        int temp = 0;   // 辅助位置交换
        boolean flag = false;  // 优化判断标识

        for (int x = 0; x < arr.length - 1; x++) {
            for (int y = 0; y < arr.length - 1 - x; y++) {
                if (arr[y] > arr[y + 1]) {
                    flag = true;
                    temp = arr[y];
                    arr[y] = arr[y + 1];
                    arr[y + 1] = temp;
                }
            }
            if (!flag) {
                break;    // 如果没有一次交换数据, 则直接结束
            }
            flag = false;  // 标识重置
        }
    }


}

快速排序 (QuickSort)

基本思想:

快速排序(QuickSort) 是对冒泡排序的一种改进, 基本思想是: 通过一趟排序将要排列的数据分割成独立的两部分, 其中一部分的所有数据都比另外一部分的所有数据都要小, 然后再按此方法对这两部分数据分别进行快速排序, 整个排序过程可以递归进行, 以此达到整个数据变成有序队列.

package com.com.beyond.dhl.utils.sort;

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {1, 5, 3, 2, 6, 7, 0, -3};
        System.out.println("快速排序前:" + Arrays.toString(arr));
        quickSort(arr, 0, arr.length-1);
        System.out.println("快速排序后:" + Arrays.toString(arr));
    }


    public static void quickSort(int[] arr, int leftF, int rightF) {
        int temp = 0; // 用于交换
        int left = leftF;  // leftF 表示为初始数组的最左下标值
        int right = rightF;  // rightF 表示初始数组的最右下标值
        int mid = arr[(left + right) / 2];  // 定义基值, 选择数组中间为基值

        while (left < right) {
            while (arr[left] < mid) {   // 在左边找到一个比 中值 大的值
                left++;
            }
            while (arr[right] > mid) {  // 在右边找到一个 比中值 小的值
                right--;
            }

            if (left >= right) {  // 如果 left > right 说明 mid 两边已经是分开的了, 即左边都是比mid小, 右边都是比 mid 大
                break;
            }


            // 进行交换
            temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;


            if (arr[left] == mid) {   // 如果交换完后, 发现这个 arr[left] == mid, 防止死循环, 即直接将 right 前移即可
                right--;
            }
            if (arr[right] == mid){   // 如果交换完后, 发现这个 arr[right] == mid, 防止死循环, 即直接将 left 后移即可
                left ++;
            }

        }

        if (right == left){    // 如果两个指针相遇
            right --;
            left ++;
        }

        // 向左递归
        if (leftF < right){
            quickSort(arr, leftF, right);
        }

        // 向右递归
        if (rightF > left){
            quickSort(arr, left, rightF);
        }

    }
}

快速排序 测试80000个随机数据的排序效率

 public static void main(String[] args) {

        int[] test = new int[80000];  // 测试数据
        for (int i = 0; i < test.length; i++) {
            test[i] = (int) (Math.random() * 1000000);  // 随机生成一个 [0,1000000) 数
        }
        long start = System.currentTimeMillis();
        quickSort(test,0,test.length-1);
        long end = System.currentTimeMillis();
        System.out.println("80000个随机数使用快速排序所耗时间为: " +(end - start)  + "毫秒");
    }