算法常识——冒泡排序

Posted aoximin

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了算法常识——冒泡排序相关的知识,希望对你有一定的参考价值。

前言

冒泡排序是一种通用的算法,凡是通用的,可以理解为效率不高,但是通用。

code

从小到大的排序:

static void Main(string[] args)
{
    int[] intarr = new int[] {1,6,8,2,3,5,10,48,9 };
    sort(intarr);
    foreach(var i in intarr)
    {
        Console.Write(i+"
");
    }
    Console.ReadKey();
}
public static void sort(int[] arr)
{
    var temp = 0;
    var hasSore = true;
    for(var i=0;i<arr.Length-1;i++)
    {
        for (var j=0;j<arr.Length-1-i;j++)
        {
            if (arr[j] > arr[j + 1])
            {
                temp = arr[j+1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
                hasSore = false;
            }
        }
        if (hasSore)
        {
            break;
        }
    }
}

这里面稍微有点难以理解的地方是如何一开始就确认:
i<arr.Length-1
j<arr.Length-1-i
先来看下冒泡排序的过程。
首先要确认i,j的意思是什么?
在这里我把i变量认为是已经排好的个数,那么其范围也就确认了,那么排好多少序后,成功呢?答案其实是arr.length-2个排序完毕,其实就不同排序了。
我们知道三个元素排序。
如果使用:
if (arr[j] > arr[j + 1])
{
temp = arr[j+1];
arr[j + 1] = arr[j];
arr[j] = temp;
hasSore = false;
}
只需要一次。假设arr.length-3排序好了,只要确认第arr.length-2个那么就确认了。
很多人第一次遇到的时候总理解为需要arr.length-1个确认好,那是因为我们理解为倒数第一个确认好,最后一个确认好。
这个其实是有公式的,为arr.length-m+1。m为一次性能够确认的值。1的意思是做好一次。
j 是该次需要多少元素排好一个元素。
1.第一步需要确认最后一个元素是最大值。
也就是说需要比较的是全部。因为j,所以比较范围是0到arr.length-1,那么j的范围是0到 arr.length-2
2.第二步需要确定倒数第二大元素是多少。
j的比较范围是0到arr.length-2,那么j的范围是0到arr.length-3,也就是确认一个后j的一个范围就不需要确认(可以解释数组缩短了),也就是 arr.length-1-i
为什么hasSore为true的时候可以break呢?因为如果顺序没有变化,那么其实已经排好了。
其实几乎达不到i=arr.length-2的情况,为何这么说呢?每循环一次,其实已经在排序了,把冒泡排序的时间排序归纳为o(n^2),也是不正确的。

继续优化

class Program
{
    static void Main(string[] args)
    {
        int[] intarr = new int[] {1,6,8,2,3,5,10,48,9 };
        sort(intarr);
        foreach(var i in intarr)
        {
            Console.Write(i+"
");
        }
        Console.ReadKey();
    }
    public static void sort(int[] arr)
    {
        var temp = 0;
        var hasSore = true;
        var sortEnd = arr.Length - 1;
        for (var i=0;i<arr.Length-1;i++)
        {
            for (var j=0;j< sortEnd; j++)
            {
                if (arr[j] > arr[j + 1])
                {
                    temp = arr[j+1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                    sortEnd = j;
                    hasSore = false;
                }
            }
            if (hasSore)
            {
                break;
            }
        }
    }
}

原理:
技术图片
上面我们只要7和6换了位子就可以了,但是计算机可不会这么做。
但是我们知道其实9和10是排好了顺序的。
如何判断到最后一个交换位置的位置,那么就可以肯定后面的位置包括了后面交换的位置是已经判断了的。
就比如说这里:
加入7和6交换了位置,然后7没有和9交换位置,9也没有和10交换位置,那么是不是可以判断6到7到9到10是排序好的?
这里难以理解的是6,为什么6也被排序好了?因为6和7比较排序的时候6肯定是前面的最大值,也就是仅次于7的值。
我们比较的是6,也就是j,那么第二次判断的时候只需要去判断0-(j-1),所以可以向上面那么做。

以上是关于算法常识——冒泡排序的主要内容,如果未能解决你的问题,请参考以下文章

算法常识——快速排序

C1认证学习十四十五(算法常识HTML Head 头)

C1认证学习十四十五(算法常识HTML Head 头)

Java常识7.0 数组实现冒泡排序选择排序和二分查找

Java常识7.0 数组实现冒泡排序选择排序和二分查找

四种排序算法实现