十大经典排序之：冒泡排序 ｜快速排序 冒泡排序 快速排序

发表于

「这是我参与11月更文挑战的第22天，活动详情查看：2021最后一次更文挑战」

冒泡排序

冒泡原理

冒泡排序相信是很多人入门必学算法，是打开我们走向算法大门的钥匙，这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

原理：比较两个相邻的元素，将值大的元素交换到右边
直观表达：每一趟遍历，将一个最大的数移到序列末尾

算法实现

1、算法描述

比较相邻的元素，如果前一个比后一个大，交换之。
第一趟排序第1个和第2个一对，比较与交换，随后第2个和第3个一对比较交换，这样直到倒数第2个和最后1个，将最大的数移动到最后一位。
第二趟将第二大的数移动至倒数第二位
……

2、图示
在这里插入图片描述
3、算法空间复杂度和时间复杂度

时间复杂度：

  • 最坏：o（n2n^{2 }n2）
  • 最好：o（nn^{}n）
  • 平均：o（n2n^{2 }n2）

空间复杂度（辅助存储）：o（1）

稳定性：稳定

例题

-》用冒泡排序将以下数列按照从小到大的顺序输出：

123,45,6,22,99,1,38,41,-6,0

java代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
java复制代码public class Test {
    public static void main(String[] args) {
        int[] arr=new int[]{123,45,6,22,99,1,38,41,-6,0};
        //冒泡排序 比较相邻的元素,如果第一个比第二个大,就交换他们两个

        //需进行length-1次冒泡
        for(int i=0;i<arr.length-1;i++)
        {
            for(int j=0;j<arr.length-1-i;j++)
            {
                if(arr[j]>arr[j+1])
                {
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        System.out.println("从小到大排序后的结果是:");
        for(int i=0;i<arr.length;i++)
            System.out.print(arr[i]+"\t");
    }

}

快速排序

快排原理

同样的，必学算法之一。快速排序（Quicksort）是对冒泡排序算法的一种改进。快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。

算法实现

1、算法描述
快速排序,说白了就是给基准数据找其正确索引位置的过程.

  1. 从数列中挑出一个元素，称为 “基准”（pivot）;
  2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

2、图示
在这里插入图片描述
3、算法空间复杂度和时间复杂度

时间复杂度：

  • 最坏：o（n2n^{2}n2）
  • 最好：o（nlog⁡2nn\log _{2}nnlog2​n）
  • 平均：o（nlog⁡2nn\log _{2}nnlog2​n）

空间复杂度（辅助存储）：o（nlog⁡2nn\log _{2}nnlog2​n）

稳定性：不稳定

例题

用快速排序将以下数列按照从小到大的顺序输出：

-》66,13,51,76,81,26,57,69,23

java代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
java复制代码public class Test {
    static void quick_sort(int q[], int l, int r)
    {
        if (l >= r) return;

        int i = l - 1, j = r + 1, x = q[l + r >> 1];
        while (i < j)
        {
            do i ++ ; while (q[i] < x);
            do j -- ; while (q[j] > x);
            //交换
            if (i < j) {
                q[i] = q[i] ^ q[j];
                q[j] = q[i] ^ q[j];
                q[i] = q[i] ^ q[j];
            }

        }

        quick_sort(q, l, j);
        quick_sort(q, j + 1, r);
    }


    public static void main(String[] args) {
        int[] arr=new int[]{66,13,51,76,81,26,57,69,23};
        //快速排序  分治
         quick_sort(arr, 0, arr.length - 1);
       

        System.out.println("快速排序后的结果是:");
        for(int i=0;i<arr.length;i++)
            System.out.print(arr[i]+"\t");
    }

}

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%