算法学习记录007_排序算法之冒泡、选择、插入

一、冒泡排序

package com.study.data.structures.sort;

import java.util.Arrays;

/**
 * 冒泡排序
 */
public class BubblingSort {

    public static void main(String[] args) {
        int[] arrays = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arrays[i] = (int) (Math.random() * 80000);
        }
        new Thread(() -> {

            method1(Arrays.copyOf(arrays, arrays.length));
        }).start();

        new Thread(() -> {
            method2(Arrays.copyOf(arrays, arrays.length));
        }).start();
    }

    private static void method1(int[] arrays) {
        int temp = 0;
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < arrays.length - 1; i++) {
            for (int j = 0; j < arrays.length - 1 - i; j++) {
                if (arrays[j] > arrays[j + 1]) {
                    temp = arrays[j];
                    arrays[j] = arrays[j + 1];
                    arrays[j + 1] = temp;
                }
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println("选择排序花费时间1：：" + (endTime - startTime));
//        System.out.println(Arrays.toString(arrays));
    }

    /**
     * 添加flag是为了减少排序次数，但是当数据过多时，执行
     * if (!flag) {
     *      break;
     * }
     * 很有可能比排序花费的时间更多
     * @param arrays
     */
    private static void method2(int[] arrays) {
        int temp = 0;
        boolean flag = false;
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < arrays.length - 1; i++) {
            flag = false;
            for (int j = 0; j < arrays.length - 1 - i; j++) {
                if (arrays[j] > arrays[j + 1]) {
                    flag = true;
                    temp = arrays[j];
                    arrays[j] = arrays[j + 1];
                    arrays[j + 1] = temp;
                }
            }
            if (!flag) {
                break;
            }
        long endTime = System.currentTimeMillis();
        System.out.println("选择排序花费时间2：：" + (endTime - startTime));
//        System.out.println(Arrays.toString(arrays));
    }
}

二、选择排序

package com.study.data.structures.sort;

import java.util.Arrays;


/**
 * 选择排序
 */
public class SelectSort {

    public static void main(String[] args) {
        int[] arrays = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arrays[i] = (int) (Math.random() * 80000);
        }
        new Thread(() -> {

            method1(Arrays.copyOf(arrays, arrays.length));
        }).start();

        new Thread(() -> {
            method2(Arrays.copyOf(arrays, arrays.length));
        }).start();
    }


    private static void method1(int[] arrays) {
        int temp = 0;
//        System.out.println(Arrays.toString(arrays));
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < arrays.length - 1; i++) {
            for (int j = i + 1; j < arrays.length; j++) {
                //method2相对于method1来说少执行了语句
                if (arrays[i] > arrays[j]) {
                    temp = arrays[i];
                    arrays[i] = arrays[j];
                    arrays[j] = temp;
                }
            }
//            System.out.println("第"+i+"轮：："+Arrays.toString(arrays));
        }
        long endTime = System.currentTimeMillis();
        System.out.println("选择排序花费时间1：：" + (endTime - startTime));

//        System.out.println(Arrays.toString(arrays));
    }
    
    private static void method2(int[] arrays) {

        int temp = 0;
        int minIndex = 0;
//        System.out.println(Arrays.toString(arrays));
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < arrays.length - 1; i++) {
            minIndex = i;
            for (int j = i + 1; j < arrays.length; j++) {
                if (arrays[minIndex] > arrays[j]) {
                    minIndex = j;
                }
            }

            if (minIndex != i) {
                temp = arrays[i];
                arrays[i] = arrays[minIndex];
                arrays[minIndex] = temp;
            }

//            System.out.println("第" + i + "轮：：" + Arrays.toString(arrays));
        }
        long endTime = System.currentTimeMillis();
        System.out.println("选择排序花费时间2：：" + (endTime - startTime));

//        System.out.println(Arrays.toString(arrays));
    }

}

三、插入排序

package com.study.data.structures.sort;

import java.util.Arrays;

public class InsertSort {
    public static void main(String[] args) {
        int[] arrays = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arrays[i] = (int) (Math.random() * 80000);
        }

        new Thread(() -> {

            method1(Arrays.copyOf(arrays, arrays.length));
        }).start();

        new Thread(() -> {
            method2(Arrays.copyOf(arrays, arrays.length));
        }).start();
    }

    private static void method1(int[] arrays) {
        int insertVal = 0;
        int insertIndex = 0;
        long startTime = System.currentTimeMillis();
        for (int i = 1; i < arrays.length; i++) {
            //先取到预排序的值
            insertVal = arrays[i];
            //取到有序数组的最后一个下标
            insertIndex = i - 1;
            //获取预排序元素应该在有序数组中的位置
            while (insertIndex >= 0 && insertVal < arrays[insertIndex]) {
                arrays[insertIndex + 1] = arrays[insertIndex];
                insertIndex--;
            }
            //将预排序的元素插入到正确的位置
            arrays[insertIndex + 1] = insertVal;

        }
        long endTime = System.currentTimeMillis();
        System.out.println("选择排序花费时间1：：" + (endTime - startTime));
    }

    /**
     * 以下代码是为了减少赋值次数
     * if (insertIndex + 1 != i) {
     *     arrays[insertIndex + 1] = insertVal;
     * }
     * 但是当数据过多时，执行条件判断的时间将会比直接执行赋值语句更耗时
     * @param arrays
     */
    private static void method2(int[] arrays) {
        int insertVal = 0;
        int insertIndex = 0;
        long startTime = System.currentTimeMillis();
        for (int i = 1; i < arrays.length; i++) {
            insertVal = arrays[i];
            insertIndex = i - 1;
            while (insertIndex >= 0 && insertVal < arrays[insertIndex]) {
                arrays[insertIndex + 1] = arrays[insertIndex];
                insertIndex--;
            }
            //此时说明走入进了for循环
            if (insertIndex + 1 != i) {
                arrays[insertIndex + 1] = insertVal;
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println("选择排序花费时间2：：" + (endTime - startTime));
    }
}

四、js版本

let arrays = [];
for (let i = 0; i < 80000; i++) {
    arrays[i] = parseInt(Math.random() * 80000)
}
// console.log('当前数组值', arrays);

bubbleSort([...arrays])
//冒泡排序
function bubbleSort(arrays) {
    let temp = 0;
    let start = Date.now();
    //减1是因为最后一轮不用再排序
    for (let i = 0; i < arrays.length - 1; i++) {
        //减1是为了防止数组越界，减i是减少排序次数
        for (let j = 0; j < arrays.length - 1 - i; j++) {
            //修改这个地方可以改变排序方式
            if (arrays[j] > arrays[j + 1]) {
                temp = arrays[j];
                arrays[j] = arrays[j + 1];
                arrays[j + 1] = temp;
            }
        }
    }
    let end = Date.now();
    // console.log('排序结果', arrays);
    console.log('冒泡排序所花时间', start, end, end - start);
}
selectSort([...arrays])
//选择排序
function selectSort(arrays) {
    let minIndex = 0;
    let temp = 0;
    let start = Date.now();
    for (let i = 0; i < arrays.length; i++) {
        minIndex = i;
        for (let j = i + 1; j < arrays.length; j++) {
            //修改这个地方可以改变排序方式
            if (arrays[minIndex] > arrays[j]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {
            temp = arrays[minIndex]
            arrays[minIndex] = arrays[i];
            arrays[i] = temp;
        }
    }
    let end = Date.now();
    // console.log('排序结果', arrays);
    console.log('选择排序所花时间', start, end, end - start);
}

insertSort([...arrays])
//插入排序
function insertSort(arrays) {
    //预排序的值
    let insertVal = 0;
    //记录有序数组的下标
    let insertIndex = 0;
    let start = Date.now();
    for (let i = 1; i < arrays.length; i++) {
        insertVal = arrays[i];
        insertIndex = i - 1;
        //修改这个地方可以改变排序方式
        while (insertIndex >= 0 && insertVal < arrays[insertIndex]) {
            //满足条件，则有序数组最后一个数往后移动一位
            arrays[insertIndex + 1] = arrays[insertIndex]
            //与有序数组的下一个值进行比较
            insertIndex--;
        }
        arrays[insertIndex + 1] = insertVal
    }
    // console.log('排序结果', arrays);
    let end = Date.now();
    console.log('插入排序所花时间', start, end, end - start);
}