JS实现快速排序算法

以下贴出两种实现方式,结果一样,但有些许的差别:

第一种:

 1         <script type="text/javascript">
 2             var arr=[6,7,8,3,4,5,9];
 3             function quicksort(left,right){
 4                 if(left>right){
 5                     return ;
 6                 }
 7                 var temp=0;
 8                 var i=right;
 9                 var j=left;
10                 temp=arr[left];
11                 while(arr[i]>arr[left]){
12                     i--;
13                 }
14                 while(arr[j]<=arr[left]){
15                     j++;
16                 }
17                 if(i>j){
18                     temp=arr[i];
19                     arr[i]=arr[j];
20                     arr[j]=temp;
21                     quicksort(left,right);
22                 }
23                 else{
24                     arr[left]=arr[i];
25                     arr[i]=temp;
26                     quicksort(left,i-1);
27                     quicksort(i+1,right);
28                 }
29             }
30             quicksort(0,6);
31             console.log(arr);
32         </script>

第二种:

 1         <script type="text/javascript">
 2             var a=[6,7,8,3,4,5,9];
 3             function quicksort(left,right){
 4                 var i,j,t,temp;
 5                 if(left>right){
 6                     return;
 7                 }
 8                 temp=a[left];
 9                 i=left;
10                 j=right;
11                 while(i!=j){
12                     while(a[j]>=temp&&i<j){
13                         j--;
14                     }
15                     while(a[i]<=temp&&i<j){
16                         i++;
17                     }
18                     if(i<j){
19                         t=a[i];
20                         a[i]=a[j];
21                         a[j]=t;
22                     }
23                 }
24                 a[left]=a[i];
25                 a[i]=temp;
26                 quicksort(left,i-1);
27                 quicksort(i+1,right);
28                 return;
29             }
30             quicksort(0,6);
31             console.log(a);
32         </script>

原文地址:https://www.cnblogs.com/mycognos/p/9175906.html

时间: 2024-10-12 12:25:11

JS实现快速排序算法的相关文章

js之快速排序算法

function quickSort(arr = [3, 7, 20, 1, 10, 6, 15, 5, 12]) { if (arr.length <= 1) return arr const leftArr,rightArr  = [], let current = null current = arr.splice(0, 1) for (let i = 0; i < arr.length; i++) { arr[i] < current ? leftArr.push(arr[i])

js实现快速排序

js实现快速排序(in-place)简述 快速排序,又称划分交换排序.以分治法为策略实现的快速排序算法. 本文主要要谈的是利用javascript实现in-place思想的快速排序 分治法: 在计算机科学中,分治法是建基于多项分支递归的一种很重要的算法范式.字面上的解释是“分而治之”,就是把一个复杂的问题分成两个或更多的相同或相似的子问题,直到最后子问题可以简单的直接求解,原问题的解即子问题的解的合并.(摘自维基百科) 快速排序的思想 数组中指定一个元素作为标尺,比它大的放到该元素后面,比它小的

快速排序算法小结

         快速排序是对冒泡排序的一种改进.它的基本思想是:通过一躺排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一不部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列.          假设要排序的数组是a[6],长度为7,首先任意选取一个数据(通常选用第一个数据)作为关键数据,然后将所有比它的数都放到它前面,所有比它大的数都放到它后面,这个过程称为一躺快速排序.一躺快速排序的算法是: 1).设

排序算法之 Java简单快速排序算法

package net.qh.test.sort; import java.util.ArrayList; import java.util.Calendar; import java.util.List; /** * Created by Administrator on 2016/03/01. */ public class SimpleQuick { public int[] sort(int[] arr,int left,int right){ if ( arr == null || a

快速排序算法

快速排序的基本思想是:通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序的目的. 稳定性:快速排序是不稳定的排序 时间复杂度: 最好:O(nlogn) 最差:O(n^2) 辅助空间:O(logn) ~ O(n) /* 快速排序算法 */ #include <cstdio> /* 对给定的闭区间进行快速排序 */ void QSort(int* L, int low, int high){ if (low

关于快速排序算法(一个90%的人都不懂其原理、99.9%的人都不能正常写出来的算法.)

一.奇怪的现象 研究快速排序很久了,发现一个古怪的实情:这算法描述起来很简单,写一个正确的出来实在不容易.写一个优秀的快速排序算法更是难上加难. 也难怪该算法提出来过了很久才有人写出一个正确的算法,过了很久才优秀的版本出来. 二.原理描述 从数列中挑出一个元素,称为 "基准"(pivot), 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边).在这个分区退出之后,该基准就处于数列的中间位置.这个称为分区(partition)操作

排序算法--快速排序算法解析

一.快速排序算法思路 ①.取待排序列表的第一个元素p,通过归位算法,挪移他到列表中正确的位置. ②.列表被元素p分成两部分,左边都比元素p小,右边都比元素p大. ③.通过递归,在两部分,重复1.2步骤,直至列表有序. 归位算法动画演示: 二.快速排序算法代码示例 1 def partition(l,left,right):#归位算法 2 temp = l[left] #保存归位元素 3 while left <right: 4 while l[right]>=temp and left<

三路快速排序算法

1.三路快速排序算法的基本思想 之前的快速排序算法都是将序列分成<=v和>v或者是<v和>=v的两个部分,而三路快速排序是将序列分成三个部分: <v.=v.>v,如下图所示: 首先v元素还是作为"基准"元素,e表示当前遍历索引值指向的元素,也就是待考虑的元素,从图中可以看出来,整个序列被分成 3个部分,也就是说当我们遍历完成之后整个序列就已经被分成了<v.=v.>v三个部分了,而我们只需要对<v和>v的两个部分 再次递归调用三

C# 集合扩展快速排序算法

/// <summary> /// 对集合进行排序,如 /// List<Person> users=new List<Person>(){.......} /// ListSorter.SortList<list<Person>,Person>( users,"Age",SortDirection.Ascending); /// </summary> public static class ListUtil {