他山之石，可以攻玉--从伪代码的角度来理解排序算法

Melonwith
1,442 阅读5分钟

在学习各种排序算法的过程中，网上看到的参考资料大部分都是类似于“xxx语言中排序算法的实现”，然后直接给出某种编程语言中各种排序算法的代码实现。这类的参考资料，容易让初学者纠结于所用的编程语言的具体语法，而对排序算法的真正逻辑的理解过于单薄。

相比于通过学习某一门编程语言的排序算法的具体实现，使用伪代码来学习排序算法，则有以下优点：

  1. 不用纠结于语法的细节，因为语法是我们自己定的
  2. 可以体会语言设计者的想法，因为语法是我们自己定的
  3. 学习过程中，我们的精力专注于算法逻辑的梳理和流程图的实现

接下来，我们就可以制订一套属于自己的语法规则。在拟写自创的语法规则之前，我们需要了解一下结构化编程的概念，这对于拟写一套可用的语法规则十分重要。

什么是结构化编程

结构化编程

是一种编程典范。它采用子程序、程式码区块、for回圈以及while回圈等结构，来取代传统的goto。希望借此来改善计算机程序的明晰性、品质以及开发时间，并且避免写出面条式代码。

通过维基百科，我们可以提炼出结构化编程的几个要点：

  1. 代码一行一行有序执行
  2. 有条件控制语句 if...else...
  3. 有循环控制语句 while(exp) do...

编写自创的语法规则

了解了结构化编程的基本概念以后，我们就可以拟写自己的语法规则了。

  1. a <- 1 表示将 1 拷贝给 a
  2. 条件控制语句:
if xxx
    1
elseif yyy
    2
else
    3
end
  1. 循环语句
 n <- 0
 while n < 10
    print n
    n <- n+1
 end
  1. length 表示一个容器, 'length' 表示字符串, length <- 'length' 表示将字符串放入容器
  2. `//``表示注释的写法

从数组找最小数字

有了我们自己的语法规则以后，现在来练习一个小例子：假设有一个数组a，里面有n个数，现在需要从a中找出最小的数。

我们想想，我们是怎么在n个数里做大小比较的，按照计算机思维，应该两两数字做对比，选出小的，再将小的数字与后面的数字两两对比，这样一直循环比较，总共做n-1次比较，最小的数字便是最后一次两两对比中那个小的。

按照以上分析，我们组织一下伪代码的写法：

//将数组赋值给a
a <- {
    '0': 23
    '1': 43
    '2': 239
    '3': 1321
    '4': 90
    'length': 5
}
//将数组第一项赋值给min
min <-  a['0']
index <- 1
//遍历数组,两两比较，取得较最小值
while index < a['length']
    if a[index] < min
        min <- a[index]
    end
    index <- index + 1
end
print min

从数组找最小数字思考冒泡排序

既然我们能够从数组n个数字中找出最小的，那稍稍思考一下，我们完全可以用这个找最小数字的方法，来给数组的n个数字做排序，流程如下：

  1. 准备一个新数组
  2. 从数组n个数字中按照找最小数的方法，找出最小的数字min， 从数组中取出min放入新数组，此时原数组还剩下n-1个数
  3. 从原数组剩下的n-1个数，重复步骤2，直到原数组所有数字被取出
  4. 此时的新数组即为排序好的数组

虽然我们完成了数组排序，但是却多用了一个新数组，原数组的项数n不大时，这看起来无关紧要，但如果n非常大时，空间浪费这个问题就比较明显了，所以我们需要优化一下流程，做到在原数组内部就能够进行排序。优化后的流程如下：

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
  3. 针对所有的元素重复以上的步骤，除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

我们尝试画一下流程图：

根据流程图的逻辑，冒泡排序的伪代码如下：

//将数组赋值给a
a <- {
    '0': 23
    '1': 43
    '2': 239
    '3': 1321
    '4': 90
    'length': 5
}
//最开始轮数为1
count <- 1
while count < a['length']
    index <- 0  
    while index < a['length'] - count
       if a[index] > a[index+1]
          //将小的数靠前排
          tmp <- a[index]
          a[index] <- a[index+1]
          a[index+1] <- tmp
       end
       index -< index + 1
    end
    //轮数加1
    count <- count + 1
end

可以看到的是，有了流程图的辅助，即使是自创的语法规则，冒泡排序也能写的异常清晰。

有了伪代码以后，我们只要稍加改动，就能以真正的编程语言来实现冒泡排序，我们以JS为例：

function bubbleSort(array) {
    var i,j,tmp;
    var length = array.length
    for(i=1;i<length;i++) {
        for(j=0;j<length -1 -i;j++) {
            if (array[j]>array[j+1]) {
                tmp = array[j];
                array[j] = array[j+1];
                array[j+1] = tmp;
            }
        }
    }
    return array
}
bubbleSort([4,3,9,8,4,7,5,2,10,35,14,86,1,2,4,3])
//[1, 2, 2, 3, 3, 4, 4, 4, 5, 7, 8, 9, 10, 14, 35, 86]

以上就是通过伪代码来学习排序算法的全过程，如果对你有帮助的的话，可以点个喜欢。

avatar
文章
阅读
粉丝