javascript实现快排

它的基本思想应该是将待排记录分成独立的两个部分,找出枢轴,实现枢轴左边的值都小于枢轴的值,枢轴右边都大于枢轴的值。这样子不断递归下去


function quicksort(arr,low,high){
        var pivot;
        if(low < high){
            pivot = partition(arr,low,high);
            quicksort(arr,low,pivot-1);
            quicksort(arr,pivot+1,high);
        }
        return arr;
    }

这个就是快排的入口函数,出现了partition方法。它的作用就是找出记录中的关键字,也就是枢轴


 function partition(arr,low,high){
 1.       var pivot = arr[low];
 2.       while(low <= high){
 3.           while(low <= high && arr[high] >= pivot){
 4.               high--;
 5.           }
 6.           swap(arr,low,high);
 7.           while(low <= high && arr[low] < pivot){
 8.               low++;
 9.           }
 10           swap(arr,low,high);
 11       }
 12       return low;
 13   }

其实它的思想也是挺简单的,比如你有这样一系列数字:5 1 9 3 7 4 8 6 2。我们这里只计算第一趟快排,其他只是递归下去,思路是一致的。

  1. 代码行1把数字列的第一个元素5作为为枢轴,跟最后一个元素2比较;
  2. 一比较不符合代码行3 arr[high] >= pivot。所以就执行交换两个位置的值;
  3. 现在的数字列为2 1 9 3 7 4 8 6 5
  4. 执行代码行7得出2 1都小于枢轴5继续循环,但是到了9时就不满足条件退出了循环。
  5. 执行交换后数字列为2 1 5 3 7 4 8 6 9
  6. 这个时候low为3 high为9 满足代码行2的循环条件继续按照前面步骤1~5执行
  7. 最后第一趟数字列为2 1 4 3 5 7 8 6 9
  8. 枢轴5的左边的值2 1 4 3都比它小,右边的值7 8 6 9都比它大

最后有一个函数就是交换函数的


 function swap(arr,low,high){
        var temp;
        temp = arr[low];
        arr[low] = arr[high];
        arr[high] = temp;
    }

这个函数实现起来还是比较简单的

如果不太了解快排方法的人可以去看《大话数据结构》,写得浅显易懂。还有就是其实可以用闭包的方法封装partition和swap方法,就暴露出quicksort方法接口给外界就行了

javascript实现快排

时间: 2024-08-29 22:15:01

javascript实现快排的相关文章

JavaScript快排与原生sort的测试

今天工作室断网!果断回宿舍,不然各种资料都没有.(他说将来会找到!)不好意思,又哼起来了.进入主题,大家都知道,快排是各种排序算法中,最高效的也是应用最广的,还有更重要的一点,面试特别爱考的! 其实大家或多或少都听说过快排,也就是先从取出一个基准值,然后再把其它的数与之相对比,小的放左边的集合里,大的放右边的集合里,再通过递归不断重复该步骤,实现最高效率的quickSort. Talk is cheap, show you my code! 排序结果我就不写出来啦,大家都会数大小,哈哈哈. 刚说

算法学习——单链表快排

/**  * 以p为轴对start-end间的节点进行快排(包括start && 不包括end):  * 思路:  * 1.将头节点作为轴节点start,从start.next开始遍历,如果节点小于轴start的值,将该节点插入到轴节点后面:  * 2.将轴节点插入合适位置,即找到最后一个小于轴的节点,将该节点与轴节点值互换,此时就链表分为两部分,小于轴节点和大于轴节点:  * 3.递归的遍历2中两部分节点.  *   * @param p  * @param start  * @para

快排的递归和非递归

常用的快排都是用递归写的,因为比较简单,但是可以用栈来实现非递归的快排. 第一种是递归的快排 #include<stdio.h> #include <stdlib.h> #include <time.h> int quick(int a[],int i ,int j) {     int tmp=0,key,b=0;     int im,jm;     im=i;     jm=j;     key=a[i];     if(i>j)         retur

快排,随机快排,双路快排,三路快排的理解

再讲快排之前,首先对于任何一个数组,无论之前是多么杂乱,排完之后是不是一定存在一个数作为分界点(也就是所谓的支点),在支点左边全是小于等于这个支点的,然后在这个支点右边的全是大于等于这个支点的,快排过程就是寻找这个支点过程 先看普通的快排(普通单路快排) 代码如下 let findIndex = (arr, l, len) => { let par = arr[l], j = l for (let i = l + 1; i <= len; i++) { if (arr[i] < par)

Quick Sort(快排)

这是挖坑填补法的演示 快排之挖坑填补法: 1 void Quick(int top/*起始位置*/,int end/*末尾位置*/,int arr[])//挖坑填补法 2 { 3 int i=top,j=end,mark;//i是记住前面的坑 j记住后面的坑 mark记住标准值 4 5 mark=arr[top];//以起始位置作为标准值,同时起始点成为第一个坑 6 if(top>=end)return; 7 while(i<j) 8 { 9 while(i<j)//从后向前找比标准值小

冒泡,快排代码+注释

冒泡: package Sort; public class BubbleSort { public static void main(String[] args) { int[] list = new int[]{12,14,3,24,1,33}; int[] nums = bubbleSort(list); for(int i = 0;i< list.length;i++){ System.out.println(nums[i]); } } public static int[] bubbl

C++ 快排

// 进行一轮快排并返回当前的中间数 int getMiddle( int* arr, int low, int high ) { auto swaparr = [&]( int i, int j ) { int tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; }; if( high - low > 0 ) { int k = arr[low], i = low, j = high; while( i != j ) { //R->L for(

python 冒泡和快排,不多说【无聊】

1 #-*-coding:utf8-*- 2 import random 3 a=[] 4 b=[] 5 def init_array(): 6 for i in range(10000): 7 v = random.randint(1,10000) 8 a.append(v) 9 b.append(v) 10 11 #冒泡 12 def sort_array(a): 13 for i in range(len(a)): 14 for j in range(i+1,len(a)): 15 if

快排的第4个参数

问题描述 我想写个能够排序多种类型的函数.   当我着手排序字符串时,  发现直接把strcmp传递给qsort后, 无法正常排序. 解决方法 我注意到strcmp的参数与快排第4个参数的形参并不一致.  我便自己写了个比较函数, 问题solved! 附上 1 /* 2 ** 比较两个字符串 3 */ 4 int str_cmp ( void const *p1, void const *p2 ) 5 { 6 char *str1; 7 char *str2; 8 9 str1 = *(char