数组结构与算法-054-076-排序算法

最新推荐文章于 2024-09-02 18:00:58 发布

1854君

最新推荐文章于 2024-09-02 18:00:58 发布

阅读量238

点赞数

文章标签：数据结构排序算法

本文链接：https://blog.csdn.net/m0_46998705/article/details/107899361

版权

本文详细介绍了多种排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序以及基数排序。通过对算法的思路图解、代码实现和速度测试，展示了每种排序算法的特点和效率。例如，冒泡排序在未优化前的时间复杂度较高，而选择排序和插入排序在特定数据集上表现良好。希尔排序通过分组策略提高了效率，快速排序在大部分情况下表现出色，归并排序和基数排序则提供了稳定的排序效果。排序算法的时间复杂度是评估其性能的重要指标。

摘要由CSDN通过智能技术生成

054-056 冒泡排序

054 冒泡排序算法思路图解

冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相信元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就旬水底下气泡一样逐渐向上冒。
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行交换，就说明序列有序，因此要在排序过程中设置一个标志 flag 判断是否进行交换，从而减少不必要的比较

在这里插入图片描述

055 冒泡排序算法代码实现

package com.old.sort_054_056;

import java.util.Arrays;

/**
 * 一共进行数组的大小 -1 次大的循环
 * 每一趟的排序的次数在逐渐减少
 */
public class BubbleSort {
   
    public static void main(String[] t) {
   
        int arr[] = {
    3, 9, -1, 10, -2};


        /**
         * 为了容易理解，把冒泡排序的演变过程展示
         *
         * 第一趟排序就是将最大的数排在最后
         */
        //临时变量
        int temp = 0;
        for (int j = 0; j < arr.length - 1 ; j++){
   
            //如果前面的数比后面的数在，交换
            if (arr[j] > arr[j + 1]){
   
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第一趟排序：");
        System.out.println(Arrays.toString(arr));
        //第二趟排序，就是将第二大的数，排在第二位
        for (int j = 0; j < arr.length - 1 - 1 ; j++){
   
            //如果前面的数比后面的数在，交换
            if (arr[j] > arr[j + 1]){
   
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第二趟排序：");
        System.out.println(Arrays.toString(arr));

        for (int j = 0; j < arr.length - 1 - 2 ; j++){
   
            //如果前面的数比后面的数在，交换
            if (arr[j] > arr[j + 1]){
   
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第三趟排序：");
        System.out.println(Arrays.toString(arr));


        for (int j = 0; j < arr.length - 1 - 3 ; j++){
   
            //如果前面的数比后面的数在，交换
            if (arr[j] > arr[j + 1]){
   
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第四趟排序：");
        System.out.println(Arrays.toString(arr));
        System.out.println();

		//冒泡排序的时间复杂度 O(n^2)
        arr = new int[]{
   3, 9, -1, 10, -2};
        for (int i = 0; i < arr.length - 1; i++) {
   
            /*
            还需要减 1，是因为 如果 j 数组的长度 - i
            第一次遍历 长度-i，此时i是0，减i=数组长度，
            而j<小于数组长度，当j到了数组长度的最后一个，即j=长度 - 1
            而if中，将 取出 j 的下一个，即等于 长度，这样就出现了数组越界
            */
            for (int j = 0; j < arr.length - i - 1; j++) {
   
                //如果前面的数比后面的数在，交换
                if (arr[j] > arr[j + 1]){
   
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println("第" + (i+1) + "趟排序：");
            System.out.println(Arrays.toString(arr));
        }
        System.out.println("冒泡排序-最终结果：");
        System.out.println(Arrays.toString(arr));
    }
}

056 冒泡排序算法优化和总结

主要思路在于如果一次都没有进行交换就跳出循环，不再进行交换，因为没有进行交换就代表数组已经是顺了。因为每次遍历都从头开始遍历，遍历的次数少的只是数组尾

package com.old.sort_054_056;

import java.util.Arrays;

/**
 * 一共进行数组的大小 -1 次大的循环
 * 每一趟的排序的次数在逐渐减少
 */
public class BubbleSort {
   
    public static void main(String[] t) {
   
        int arr[] = {
   3, 9, -1, 10, -2};


        /**
         * 为了容易理解，把冒泡排序的演变过程展示
         *
         * 第一趟排序就是将最大的数排在最后
         */
        //临时变量
        int temp = 0;
        for (int j = 0; j < arr.length - 1; j++) {
   
            //如果前面的数比后面的数在，交换
            if (arr[j] > arr[j + 1]) {
   
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第一趟排序：");
        System.out.println(Arrays.toString(arr));
        //第二趟排序，就是将第二大的数，排在第二位
        for (int j = 0; j < arr.length - 1 - 1; j++) {
   
            //如果前面的数比后面的数在，交换
            if (arr[j] > arr[j + 1]) {
   
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第二趟排序：");
        System.out.println(Arrays.toString(arr));

        for (int j = 0; j < arr.length - 1 - 2; j++) {
   
            //如果前面的数比后面的数在，交换
            if (arr[j] > arr[j + 1]) {
   
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第三趟排序：");
        System.out.println(Arrays.toString(arr));


        for (int j = 0; j < arr.length - 1 - 3; j++) {
   
            //如果前面的数比后面的数在，交换
            if (arr[j] > arr[j + 1]) {
   
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第四趟排序：");
        System.out.println(Arrays.toString(arr));
        System.out.println();

        arr = new int[]{
   3, 9, -1, 10, -2};
        arr = new int[]{
   3, 9, -1, 10, 20};
        //arr = new int[]{1, 2, 3,4, 5};
        //标识变量，表示是否进行过交换
        boolean flag = false;
        for (int i = 0; i < arr.length - 1; i++) {
   
            /*
            还需要减 1，是因为 如果 j 数组的长度 - i
            第一次遍历 长度-i，此时i是0，减i=数组长度，
            而j<小于数组长度，当j到了数组长度的最后一个，即j=长度 - 1
            而if中，将 取出 j 的下一个，即等于 长度，这样就出现了数组越界
            */
            for (int j = 0; j < arr.length - i - 1; j++) {
   
                //如果前面的数比后面的数在，交换
                if (arr[j] > arr[j + 1]) {
   
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if (flag == false) {
   
                //说明一次都没有发生
                break;
            } else {
   
                //重置，进行下次的判断，如果不重置会一直是true，就没有效了
                flag = false;
            }
            System.out.println("第" + (i + 1) + "趟排序：");
            System.out.println(Arrays.toString(arr));
        }
        System.out.println("冒泡排序-最终结果：");
        System.out.println(Arrays.toString(arr));
        System.out.println();

        arr = new int[]{
   3, 9, -1, 10, -2};
        sort(arr);

    }


	/**
	* 这种情况也只可以，将外层从 1 开始，小于等于数组长度，内层循环无需再减1
	*/
    public static void sort(int[] arr) {
   
        //临时变量
        int temp = 0;
        //标识变量，表示是否进行过交换
        boolean flag = false;
        //这里变为了 从1开始，i小于等于 数组长度减1
        for (int i = 1; i <= arr.length - 1; i++) {
   
            //里面的循环也没有减1了
            for (int j = 0; j < arr.length - i; j++) {
   
                //如果前面的数比后面的数在，交换
                if (arr[j] > arr[j + 1]) {
   
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if (flag == false) {
   
                break;
            } else {
   
                flag = false;
            }
            System.out.println("第" + (i) + "趟排序：");
            System.out.println(Arrays.toString(arr));
        }
        System.out.

最低0.47元/天解锁文章

1854君

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数组结构与算法-054-076-排序算法

054-056 冒泡排序054 冒泡排序算法思路图解冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相信元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就旬水底下气泡一样逐渐向上冒。因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行交换，就说明序列有序，因此要在排序过程中设置一个标志 flag 判断是否进行交换，从而减少不必要的比较055 冒泡排序算法代码实现package com.old.sort_0
复制链接

扫一扫