20210416Java冒泡、插入、选择排序

冒泡排序、插入排序、选择排序

编辑时间：2021/04/16

读完本节：大概花费12钟，共1293词

1.冒泡排序

/**
 * 冒泡排序
 * <p>
 * 冒泡排序思想:<br/>
 * (从小到大):
 * 相邻两个元素进行比较,如果前一个元素比后一个元素大,则两个元素互换值;<br/>
 * (从大到小):相邻两个元素进行比较,如果前一个元素比后一个元素小,则两个元素互换值
 * <p>
 * 冒泡排序的时间复杂度:
 * average:o(n平方)
 * worst:o(n平方)
 * best:o(n)
 * <p>
 * 空间复杂度:
 * o(1)
 * <p>
 * 排序稳定性:
 * 稳定
 *
 * @Author: xuehai.XUE
 * @MailBox: xuehai.xue@qq.com
 * @Date: 2021/4/16 13:34
 */
public class BubbleSortTest {

    public static void main(String[] args) {
        //待排数组
        int[] arr = new int[]{43, 32, 76, -98, 0, 64, 33, -21, 32, 99};

        //测试用例1:升序
        BubbleSortTest b = new BubbleSortTest();
        b.bubbleSort(arr, false);

        for (int a : arr) {
            System.out.print(a + " ");
        }

        System.out.println();

        //测试用例2:降序
        BubbleSortTest b1 = new BubbleSortTest();
        b1.bubbleSort(arr, true);

        for (int a : arr) {
            System.out.print(a + " ");
        }
    }

    /**
     * 对待排数组进行冒泡排序
     *
     * @param srcArr 待排数组
     * @param desc   指定排序方式 :<br/>
     *               &nbsp;desc = true -> 降序;<br/>
     *               &nbsp;desc = false -> 升序.
     * @return 返回已排序数组
     */
    public int[] bubbleSort(int[] srcArr, boolean desc) {
        if (desc) {
            //降序
            for (int i = 0; i < srcArr.length - 1; i++) {
                for (int j = 0; j < srcArr.length - 1; j++) {
                    if (srcArr[j] < srcArr[j + 1]) {
                        int temp = srcArr[j];
                        srcArr[j] = srcArr[j + 1];
                        srcArr[j + 1] = temp;
                    }
                }
            }
        } else {
            //升序
            for (int i = 0; i < srcArr.length - 1; i++) {
                for (int j = 0; j < srcArr.length - 1; j++) {
                    if (srcArr[j] > srcArr[j + 1]) {
                        int temp = srcArr[j];
                        srcArr[j] = srcArr[j + 1];
                        srcArr[j + 1] = temp;
                    }
                }
            }
        }
        return srcArr;
    }
}

2.插入排序

/**
 * 插入排序
 * <p>
 * 插入排序思想:<br/>
 * 将待排数组分为有序和无序两个部分,开始时有序部分没有任何元素,将待排数组左始元素放入有序序列,
 * 无序序列中从左向右依次取出元素,按顺序插入到有序序列中,
 * 直到无序序列中的元素遍历结束,返回结果数组.
 * <p>
 * 插入排序的时间复杂度:
 * average:o(n平方)
 * worst:o(n平方)
 * best:o(n)
 * <p>
 * 空间复杂度:
 * o(1)
 * <p>
 * 排序稳定性:
 * 稳定
 *
 * @Author: xuehai.XUE
 * @MailBox: xuehai.xue@qq.com
 * @Date: 2021/4/16 15:21
 */
public class InsertionSortTest {
    public static void main(String[] args) {
        //待排数组
        int[] arr = new int[]{43, 32, 76, -98, 0, 64, 33, -21, 32, 99};

        //测试用例1:升序
        InsertionSortTest i1 = new InsertionSortTest();
        i1.insertionSort(arr, false);

        for (int a : arr) {
            System.out.print(a + " ");
        }

        System.out.println();

        //测试用例1:降序
        InsertionSortTest i2 = new InsertionSortTest();
        i2.insertionSort(arr, true);

        for (int a : arr) {
            System.out.print(a + " ");
        }
    }

    /**
     * 插入排序
     * @param srcArr 待排序数组
     * @param desc 指定排序方式 :<br/>
     *             &nbsp;desc = true -> 降序;<br/>
     *             &nbsp;desc = false -> 升序.
     * @return
     */
    public int[] insertionSort(int[] srcArr, boolean desc) {

        if (desc) {
            //降序
            for (int i = 1; i <= srcArr.length - 1; i++) {
                //a[i]是最左边的无序元素,每次循环都将a[i]放到合适的位置
                for (int j = 0; j < i; j++) {
                    if(srcArr[j] < srcArr[i]){
                        //将i位置上的元素放置到j上,j~i-1的元素向后移动一位
                        int temp = srcArr[i];
                        for (int k = i; k > j; k--) {
                            srcArr[k] = srcArr[k - 1];
                        }
                        srcArr[j] = temp;
                        break;
                    }
                }
            }
        } else {
            //升序
            for (int i = 1; i <= srcArr.length - 1; i++) {
                //a[i]是最左边的无序元素,每次循环都将a[i]放到合适的位置
                for (int j = 0; j < i; j++) {
                    if(srcArr[j] > srcArr[i]){
                        //将i位置上的元素放置到j上,j~i-1的元素向后移动一位
                        int temp = srcArr[i];
                        for (int k = i; k > j; k--) {
                            srcArr[k] = srcArr[k - 1];
                        }
                        srcArr[j] = temp;
                        break;
                    }
                }
            }
        }

        return srcArr;
    }
}

3.选择排序

/**
 * 选择排序
 * <p>
 * 选择排序思想:<br/>
 * 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
 * 然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
 * 以此类推，直到所有元素均排序完毕。
 * <p>
 * 选择排序的时间复杂度:
 * average:o(n平方)
 * worst:o(n平方)
 * best:o(n平方)
 * <p>
 * 空间复杂度:
 * o(1)
 * <p>
 * 排序稳定性:
 * 不稳定
 *
 * @Author: xuehai.XUE
 * @MailBox: xuehai.xue@qq.com
 * @Date: 2021/4/16 16:56
 */
public class SelectSortTest {
    public static void main(String[] args) {
        //待排数组
        int[] arr = new int[]{43, 32, 76, -98, 0, 64, 33, -21, 32, 99};

        //测试用例1:升序
        SelectSortTest s1 = new SelectSortTest();
        s1.selectSort(arr, false);

        for (int a : arr) {
            System.out.print(a + " ");
        }

        System.out.println();

        //测试用例2:降序
        SelectSortTest s2 = new SelectSortTest();
        s2.selectSort(arr, true);

        for (int a : arr) {
            System.out.print(a + " ");
        }
    }

    public int[] selectSort(int[] srcArr, boolean desc) {
        if (desc) {
            //降序
            //交换次数
            for (int i = 0; i <= srcArr.length - 1; i++) {
                //每一个元素都和剩下的未排序的元素比较
                for (int j = i + 1; j <= srcArr.length - 1; j++) {
                    //寻找最小数
                    if (srcArr[j] > srcArr[i]) {
                        //经过一轮循环，就可以找出第一个最小值的索引，然后把最小值放到i的位置
                        int temp = srcArr[i];
                        srcArr[i] = srcArr[j];
                        srcArr[j] = temp;
                    }
                }
            }

        } else {
            //升序
            //交换次数
            for (int i = 0; i <= srcArr.length - 1; i++) {
                //每一个元素都和剩下的未排序的元素比较
                for (int j = i + 1; j <= srcArr.length - 1; j++) {
                    //寻找最小数
                    if (srcArr[j] < srcArr[i]) {
                        //经过一轮循环，就可以找出第一个最小值的索引，然后把最小值放到i的位置
                        int temp = srcArr[i];
                        srcArr[i] = srcArr[j];
                        srcArr[j] = temp;
                    }
                }
            }

        }

        return srcArr;
    }
}

STAY ANGER!!!