码迷,mamicode.com
首页 > 编程语言 > 详细

快速排序的JavaScript实现

时间:2018-06-24 17:55:11      阅读:174      评论:0      收藏:0      [点我收藏+]

标签:dex   快速   index   func   asc   ===   组成   sort   一个   

思想

分治的思想,将原始数组分为较小的数组(但没有像归并排序一样将它们分隔开)。

  1. 主元选择: 从数组中任意选择一项作为主元,通常为数组的第一项,即arr[i];或数组的中间项, arr[Math.floor((i+j)/2)];
  2. 划分操作: 创建两个指针,左边一个指向数组的第一项,右边一个指向数组的最后一项。向右移动左指针,直到找到一个不小于比主元的项;向左移动右指针,直到找到一个不大于主元的项。交换它们。然后重复这个过程,直到左指针超过了右指针。这样使得比主元小的值都排在主元之前,而比主元大的值都排在主元之后。注意:在这个过程中,主元的位置也可能发生了改变;而主元本身在一次划分操作之后不会在正确的位置,其正确的位置应该在本次划分操作后最终得到的那个分割点上(即sliceIndex上),在下轮操作的右半路操作会立刻把主元换到正确的位置上
  3. 对子数组重复划分操作: 比主元小的项(即主元左边的部分)组成一个子数组,比主元大的项(即主元右边的部分)组成另一个子数组。对这两个小数组继续执行主元选择和划分操作。直到数组已完全排序。

代码

代码段1:

function quickSort(arr) {
  return quick(arr, 0, arr.length-1);
}
function quick(arr, left, right) {
  if(arr.length>1) {
    const sliceIndex = partition(arr, left, right);
    if (left < sliceIndex-1) {
      quick(arr, left, sliceIndex-1);
    }
    if (sliceIndex < right) { //*1
      quick(arr, sliceIndex, right);//*2
    }
  }  
}
function partition(arr, left, right) {
  let i = left;
  let j = right;
  //const pivot = arr[Math.floor((i+j)/2)];
  const pivot = arr[i];
  while(i< j) { 
    while (arr[i] < pivot) { // *3
    //Q:*3,*4:为什么这里必须用<和>, 而不能用 <=或>= ?
    //A:*3和*4必须是<和>,都不能包含=的情况——实际验证结果也是如此
    //因为如果包含=,那么就永远不处理pivot及值等于pivot的情况
      i++;
    }
    while (arr[j] > pivot) { // *4
      j--;
    }
    if(i<j) { // *5 
    //思考:为什么这里必须是 <= 而不能用 < ?
    //A:它其实是为了下面一段的i++,j--。如果分开两段写,那么这里应该是i<j,而下面一段应该是i<=j
      const temp = arr[i];
      arr[i] = arr[j];
      arr[j] = temp;
    }
    if(i<=j) {//*6
      //这里条件一定要是i<=j。 
      //如果条件仅仅是i<j,那么当i==j的时候就永远也进入不了这个条件,return 的值就是i也是j。那么这一整段partion代码下来,i可能从来没有变过,又原封不动地return了i,即  const sliceIndex = partition(arr, left, right);的这个sliceIndex是和参数left相等的,那么在接下来的quick(arr, sliceIndex, right)就等于之前的quick(arr,left,right),无限循环了。。。
      //总之,这个条件的目的就是让i一定要改变一次
      i++;
      j--;
    }
  }
  return i;
}

思考

1. 其实每次划分操作之后,主元并不在正确的位置上……那么为什么说每次划分操作都把比主元小的值排在了主元之前,而把比主元大的值都排在了主元之后?

主元本身在一次划分操作之后确实不在正确的位置,其正确的位置应该在本次划分操作后最终得到的那个分割点上(即sliceIndex上),在下轮操作的右半路操作会立刻把主元换到正确的位置上。所以其实在本轮划分操作最后,可以把主元交换到正确的位置上,再进行下轮操作,然后下轮操作就可以不管sliceIndex那个位置上了。

这种写法其实是把小于主元的放到左边,大于主元的放到右边,等于主元的可能在左可能在右,而并不是把主元放在了正确的位置

代码改进成如下这样就好理解了。

代码段2:

function quickSort(arr) {
  return quick(arr, 0, arr.length-1);
}
function quick(arr, left, right) {
  if (arr.length ===1) {
    return;
  }
  const sliceIndex = partition(arr, left, right);
  if(left < sliceIndex-1) {
    quick(arr, left, sliceIndex-1);
  }
  //下次划分不用再考虑主元了
  if(sliceIndex + 1 < right) { //*1
    quick(arr, sliceIndex + 1, right);//*2
  }
}

function partition(arr, left, right) {
  let i = left;
  let j = right;
  const pivot = arr[i];
  while(i < j) {
    while(arr[i] < pivot) { //*3
      i++;
    }
    while(arr[j] > pivot) {
      j--;
    }
    if(i < j) {
      const temp = arr[i];
      arr[i] = arr[j];
      arr[j] = temp;
    }
    if(i <= j) { 
      i++;
      j--;
    }
  }

  //交换主元到划分位置上
  const tempPivotIndex = arr.indexOf(pivot); //*7
  arr[tempPivotIndex] = arr[i];//*8
  arr[i]=pivot;//*9
  return i;//其实也是等于j的
}

比起原代码,这种写法:把1,2做了修改,下次划分操作不再考虑本次的slickIndex(即主元已经排好了);然后新增7,8,*9,就是在本次的划分操作最后,把主元交换到了正确的位置上,这样写,与Es6写法(代码段3)的思路是一致的

工作过程

待画图

性能分析

  • 时间复杂度: 最好、平均O(nlogn),最坏O(n^2)
  • 空间复杂度: O(logn), 不稳定
  • 特点:越有性能却差

延伸:es6的实现

代码段3:

  function quickSortEs6(arr) {
    if (!arr.length) { 
      //要处理的临界条件一定是arr为空的情况,因为可能filter过滤后就一项也不剩了
      //arr长度为1的条件可以不单独处理,因为长度为1那么[pivot, ...rest]=arr的rest就为[]了
      return [];
    }

    const [pivot, ...rest] = arr;
    return [
      ...quickSortEs6(rest.filter(item => item < pivot)),
      pivot,
      ...quickSortEs6(rest.filter(item => item >= pivot)) //一定要有=不然和pivot相等的其他值会被过滤掉
    ]
  }

这个比起之前的排法更好理解。

参考资料

-《学习JavaScript数据结构和算法》10.1.5
-《数据结构(C语言版)》9.3.2

快速排序的JavaScript实现

标签:dex   快速   index   func   asc   ===   组成   sort   一个   

原文地址:https://www.cnblogs.com/Bonnie3449/p/9221039.html

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