码迷,mamicode.com
首页 > 其他好文 > 详细

快速排序

时间:2014-06-28 22:32:26      阅读:486      评论:0      收藏:0      [点我收藏+]

标签:style   blog   http   java   color   get   

快速排序(Quicksort)的Javascript实现

作者: 阮一峰

日本程序员norahiko,写了一个排序算法的动画演示,非常有趣。

这个周末,我就用它当做教材,好好学习了一下各种排序算法。

bubuko.com,布布扣

排序算法(Sorting algorithm)是计算机科学最古老、最基本的课题之一。要想成为合格的程序员,就必须理解和掌握各种排序算法。

目前,最常见的排序算法大概有七八种,其中"快速排序"(Quicksort)使用得最广泛,速度也较快。它是图灵奖得主C. A. R. Hoare(1934--)于1960时提出来的。

bubuko.com,布布扣

"快速排序"的思想很简单,整个排序过程只需要三步:

  (1)在数据集之中,选择一个元素作为"基准"(pivot)。

  (2)所有小于"基准"的元素,都移到"基准"的左边;所有大于"基准"的元素,都移到"基准"的右边。

  (3)对"基准"左边和右边的两个子集,不断重复第一步和第二步,直到所有子集只剩下一个元素为止。

举例来说,现在有一个数据集{85, 24, 63, 45, 17, 31, 96, 50},怎么对其排序呢?

第一步,选择中间的元素45作为"基准"。(基准值可以任意选择,但是选择中间的值比较容易理解。)

bubuko.com,布布扣

第二步,按照顺序,将每个元素与"基准"进行比较,形成两个子集,一个"小于45",另一个"大于等于45"。

bubuko.com,布布扣

第三步,对两个子集不断重复第一步和第二步,直到所有子集只剩下一个元素为止。

bubuko.com,布布扣

bubuko.com,布布扣

bubuko.com,布布扣

bubuko.com,布布扣

下面参照网上的资料(这里这里),用Javascript语言实现上面的算法。

首先,定义一个quickSort函数,它的参数是一个数组。

var quickSort = function(arr) {

};

然后,检查数组的元素个数,如果小于等于1,就返回。

var quickSort = function(arr) {

  if (arr.length <= 1) { return arr; }

};

接着,选择"基准"(pivot),并将其与原数组分离,再定义两个空数组,用来存放一左一右的两个子集。

var quickSort = function(arr) {

  if (arr.length <= 1) { return arr; }

  var pivotIndex = Math.floor(arr.length / 2) ;

  var pivot = arr.splice(pivotIndex, 1)[0];

  var left = [];

  var right = [];

};

然后,开始遍历数组,小于"基准"的元素放入左边的子集,大于基准的元素放入右边的子集。

var quickSort = function(arr) {

  if (arr.length <= 1) { return arr; }

  var pivotIndex = Math.floor(arr.length / 2) ;

  var pivot = arr.splice(pivotIndex, 1)[0];

  var left = [];

  var right = [];

  for (var i = 0; i < arr.length; i++){

    if (arr[i] < pivot) {

      left.push(arr[i]);

    } else {

      right.push(arr[i]);

    }

  }

};

最后,使用递归不断重复这个过程,就可以得到排序后的数组。

var quickSort = function(arr) {

  if (arr.length <= 1) { return arr; }

  var pivotIndex = Math.floor(arr.length / 2);

  var pivot = arr.splice(pivotIndex, 1)[0];

  var left = [];

  var right = [];

  for (var i = 0; i < arr.length; i++){

    if (arr[i] < pivot) {

      left.push(arr[i]);

    } else {

      right.push(arr[i]);

    }

  }

  return quickSort(left).concat([pivot], quickSort(right));

};

使用的时候,直接调用quickSort()就行了。

bubuko.com,布布扣

(完)

文档信息

留言(38条)

好东西!谢谢!

BlueDream 说:

通俗易懂

wordgold 说:

取数组中间值的时候为什么不直接取而要Splice,如果是为了后续循环好像没必要

limon 说:

why I love python:

q_sort= lambda l: l if len(l)<=1 else q_sort([x for x in l[1:] if x<l[0]])+[l[0]]+q_sort([x for x in l[1:] if x<=l[0]])

chenge 说:

相当好,感谢分享!

reader 说:

In Haskell

quicksort :: (Ord a) => [a] -> [a] 
quicksort [] = [] 
quicksort (x:xs) = 
  let smallerSorted = quicksort [a | a <- xs, a <= x]
    biggerSorted = quicksort [a | a <- xs, a > x] 
  in smallerSorted ++ [x] ++ biggerSorted

见 Learn You a Haskell for Great Good! 一书

AnLuoRidge 说:

引用reader的发言:

In Haskell

见 Learn You a Haskell for Great Good! 一书

函数式编程的确够简洁

tumutanzi 说:

这个太专业了吧,看不懂~~不过阮兄还是辛苦了。

Richard Lee 说:

大于"基准"的元素放入左边的子集,小于基准的元素放入右边的子集。

反了,应该是:

小于"基准"的元素放入左边的子集,大于基准的元素放入右边的子集。

wells.tang 说:

引用wordgold的发言:

取数组中间值的时候为什么不直接取而要Splice,如果是为了后续循环好像没必要

有道理。

阮一峰 说:

@Richard Lee:谢谢提醒,确实写错了,已更正。

@wordgold:想了一下,你说得对,没必要splice,只要在遍历数组的时候,只要跳过“基准”元素就行了,这样代码也更易读。谢谢。

wiki 说:

赞,快速排序是递归的经典应用

Ted 说:

In Erlang:

  qsort([]) ->> [];
  qsort([Pivot|T])->
    qsort([X || X <- T, X < Pivot])
    ++[Pivot]++
    qsort([X || X <- T, X > Pivot]).

gg 说:

可以写得列简洁些的,此类题其实初中生都能看懂.

adriangong 说:

@limon:能具体说明吗?

iotioa 说:

每排一次都要新建两个一左一右的数组,那一个非常大的数组,递归非常多次,那要消耗多少内存呢?

findfunaax 说:

引用iotioa的发言:

每排一次都要新建两个一左一右的数组,那一个非常大的数组,递归非常多次,那要消耗多少内存呢?

是啊,快速排序算法的优点之一就是可以原地排序,博主这样浪费掉了这个特性。

那个排序演示很有趣~

伦布大陆 说:

这个不错啊,以前的那本数据结构都是伪代码~~~

xieranmaya 说:

那啥,Array对象不是有sort()方法吗

big apple 说:

基本原理是实现了,但有一点不尽如人意的地方。
排序后得到的数组不是原来数组了。
如:
var a=[2,1,5,7,4,10,5];
alert(a==quickSort(a));//此处得到结果是false
一般来说,执行排序方法后,原来数组顺序就改变了,但还是原来的数组。
楼主的做法相当于返回了另一个数组。

big apple 说:

js数组自带排序方法就是如此
alert(a==a.sort());//返回true

evan 说:

觉的你这个网站的技术文章太好了,加为收藏,定时拜读。

Tyler Long 说:

我解释下Limon提到的python的代码:

q_sort= lambda l: l if len(l)<=1 else q_sort([x for x in l[1:] if x<l[0]])+[l[0]]+q_sort([x for x in l[1:] if x<=l[0]])

首先lambda是用来动态声明一个函数的. 这个函数接受一个参数l, l很明显是python的list类型. 
这个函数本身赋值给了等号左边的q_sort.

接下来分析右边的函数:
l if len(l) else 后面的部分是如果l的长度大于1就会执行

接下来分析else后面的部分:
采用l的第一个元素l[0]为"基准".
有两个+号,把三段list连接为一个list:
第一段list是小于l[0]的元素快速排序的结果
第二段list就只包含l[0]一个元素
第三段list是大于l[0]的元素快速排序的结果.
三段加起来就是最终的结果, 并且是排好序的. 其中第一段和第三段的生成过程中, 递归调用了q_sort本身.

但是, Simon的这个代码是无法得出正确的结果的! 也就是说是错的! 以下是示例运行结果:
>>> q_sort= lambda l: l if len(l)<=1 else q_sort([x for x in l[1:] if x<l[0]])+[l[0]]+q_sort([x for x in l[1:] if x<=l[0]])
>>> print q_sort([2,3,5,6,3,1,8,5])
[1, 2, 1]

接下来我会留言分析下为什么Simon给出的python解决方案是错的.

Tyler Long 说:

Simon的代码之所不行,是因为它打错了一个字符. 最后的"="
一开始我以为是什么隐蔽的错误呢, 没想到是这么明显的.

魏蕤 说:

引用阮一峰的发言:

@wordgold:想了一下,你说得对,没必要splice,只要在遍历数组的时候,只要跳过“基准”元素就行了,这样代码也更易读。谢谢。

调用javascript的splice方法很好啊。

此处var pivot = arr.splice(pivotIndex, 1)[0]有两个作用:

(1)将“基准”从arr数组删除

(2)将arr数组的“基准”赋值给pivot

如果按照@wordgold直接取,则后面还需要写一段将“基准”元素从arr数组删除的代码,这样一来代码反而更多。阮兄的代码很精简,拜读。

Tyler Long 说:

用C#代码实现:
Func<IEnumerable<IComparable>, IEnumerable<IComparable>> quick_sort = null; 
quick_sort = new Func<IEnumerable<IComparable>, IEnumerable<IComparable>>(l => l.Count() <= 1 ? l : quick_sort(l.Skip(1).Where(t => t.CompareTo(l.ElementAt(0)) < 0)).Concat(new IComparable[] { l.ElementAt(0) }).Concat(quick_sort(l.Skip(1).Where(t => t.CompareTo(l.ElementAt(0)) >= 0))));

Alex 说:

博主在编程方面的日志稍微少了点。可否写一些关于日常项目中的设计思想的日志,如果你愿意分享的话。

wordgold 说:

引用魏蕤的发言:

调用javascript的splice方法很好啊。

此处var pivot = arr.splice(pivotIndex, 1)[0]有两个作用:

(1)将“基准”从arr数组删除

(2)将arr数组的“基准”赋值给pivot

如果按照@wordgold直接取,则后面还需要写一段将“基准”元素从arr数组删除的代码,这样一来代码反而更多。阮兄的代码很精简,拜读。

不需要删除啊,仔细想想,比较的时候只比较大于小于没有等于就相当于删除了的

percy 说:

这个对理解quicksort的思想有好处,但实际应用中,quicksort一般会采取"in place"的做法,不应该引入额外的数组,若是这样,quicksort与mergesort都差不多了

percy 说:

这篇贴子的点击率还挺高的,希望博主更改成就地排序,不然可能会误导初学者啊

toming 说:

haskell的可以更简单:
qsort [] = []
qsort (x:xs) = qsort [y | y <- xs, y < x] ++ [x] ++ qsort [y | y <- xs, y >= x]

这里有所有语言的qsort实现大全:http://rosettacode.org/wiki/Sorting_algorithms/Quicksort
几个函数语言haskell、erlang、ocaml、clojure的实现是最简洁的。

任迪 说:

嘿嘿 谢谢分享 这是我下一步要学习的

秦强强 说:

添个js原地排序的版本:

function quick (start ,end){
var mid = start , temp = arr[start];
for(var i = start+1 ; i if(arr[i] arr[mid]=arr[i];// >> mid+1 i-1
var j = i ; 
mid++;
while(j!=mid){arr[j]=arr[j-1];j--}

}
arr[mid]= temp ;
return mid;
}

function sort (start , end ){
if(end>start){
var mid = quick(start ,end);console.log(mid)
sort(start,mid-1);sort(mid+1,end);
}
}

sort(0,arr.length)
console.log(arr);

redfish 说:

引用Tyler Long的发言:

Simon的代码之所不行,是因为它打错了一个字符. 最后的"="
一开始我以为是什么隐蔽的错误呢, 没想到是这么明显的.


你也够粗心的,不是最后的“=”,是if x<=l[0]]) 这里面的 < 要改成 > 就对了

nebula 说:

引用wordgold的发言:

取数组中间值的时候为什么不直接取而要Splice,如果是为了后续循环好像没必要

splice会对原数组做操作,这里获取pivot的同时,还从原数组中删除了pivot。

Nebula 说:

引用findfunaax的发言:

是啊,快速排序算法的优点之一就是可以原地排序,博主这样浪费掉了这个特性。

那个排序演示很有趣~

快速排序的递归部分并不是原地排序的,所以原地排序并不是快速排序的优点。

巴晓鹏 说:

why i love ruby?

def quick_sort(a) 
  (x=a.pop) ? quick_sort(a.select{|i| i x}) : [] 
end

Troland 说:

挺好的,就是如果在对比的时候不加上那个不用splice在循环的时候判断是否和pivoet相等会少递归循环。。而且会比较好读。。

我要发表看法

 «-必填

 «-必填,不公开

 «-我信任你,不会填写广告链接

快速排序,布布扣,bubuko.com

快速排序

标签:style   blog   http   java   color   get   

原文地址:http://www.cnblogs.com/xiaoleidiv/p/3794331.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!