数组排序js

JS实现数组排序的方法有哪些

一、 冒泡排序

平均复杂度：o(n^2) 空间复杂度：o(1) 稳定性：稳定。

步骤： 1、比较相邻的元素。如果第一个比第二个大，就交换他们两个；

2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样，最后的元素应该会是最大的数；

3、针对所有的元素重复以上的步骤，除了最后一个；

4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

二、选择排序

平均复杂度：o(n^2) 空间复杂度：o(1) 稳定性：不稳定。

步骤： 1、每一次循环，找到最小的那个数，并用变量记住它的索引。

2、然后将最小值放在它该在的位置上。

3、持续对越来越少的元素重复上面的步骤。

三、插入排序

平均复杂度：o(n^2) 空间复杂度：o(1) 稳定性：稳定。

（1）直接插入排序：将第一个数和第二个数排序，然后构成一个有序序列；将第三个数插入进去，构成一个新的有序序列；对第四个数、第五个数......直到最后一个数，重复第二步。

（2）二分插入排序：将寻找每个数插入位置的方法改为折半比较即可。

四、Shell排序（插入排序的一种，又称为缩小增量排序）

平均复杂度：o(nlogn) 空间复杂度：o(1) 稳定性：不稳定。

步骤：把数组按下标的一定增量分组，然后对每组使用直接插入排序 。

想学习更多前端开发的知识，就来北京尚学堂！

js中数组排序的方法

从给定的数据中，随机抽出一项，这项的左边放所有比它小的，右边放比它大的，然后再分别这两边执行上述操作，采用的是递归的思想，总结出来就是　实现一层，分别给两边递归，设置好出口。

function fastSort(array,head,tail){。

    //考虑到给每个分区操作的时候都是在原有的数组中进行操作的，所以这里head,tail来确定分片的位置。

    /*生成随机项*/

    var randomnum = Math.floor(ranDom(head,tail));。

    var random = array[randomnum];。

    /*将小于random的项放置在其左边  策略就是通过一个临时的数组来储存分好区的结果，再到原数组中替换*/。

    var arrayTemp = [];。

    var unshiftHead = 0;。

    for(var i = head;i <= tail;i++){。

      if(array[i]<random){。

        arrayTemp.unshift(array[i]);。

        unshiftHead++;。

      }else if(array[i]>random){。

        arrayTemp.push(array[i]);。

      }

      /*当它等于的时候放哪，这里我想选择放到队列的前面，也就是从unshift后的第一个位置放置*/。

      if(array[i]===random){。

        arrayTemp.splice(unshiftHead,0,array[i]);。

      }

    }

    /*将对应项覆盖原来的记录*/。

    for(var j = head , u=0;j <= tail;j++,u++){。

      array.splice(j,1,arrayTemp[u]);。

    }

    /*寻找中间项所在的index*/。

    var nowIndex = array.indexOf(random);。

    /*设置出口，当要放进去的片段只有2项的时候就可以收工了*/。

    if(arrayTemp.length <= 2){。

      return;

    }

    /*递归，同时应用其左右两个区域*/。

    fastSort(array,head,nowIndex);。

    fastSort(array,nowIndex+1,tail);。

  }

JavaScript实现多维数组、对象数组排序，其实用的就是原生的sort()方法，用于对数组的元素进行排序。

sort() 方法用于对数组的元素进行排序。语法如下：

arrayObject.sort(sortby)。

例如：

function NumAscSort(a,b)。

 return a - b;

function NumDescSort(a,b)。

 return b - a;

var arr = new Array( 3600, 5010, 10100, 801); 。

arr.sort(NumDescSort);。

alert(arr);

arr.sort(NumAscSort);。

alert(arr);

常见的几种数组排序算法JS实现

//排序算法

window.onload = function(){。

    var array = [0,1,2,44,4,。

                324,5,65,6,6,。

                34,4,5,6,2,。

                43,5,6,62,43,。

                5,1,4,51,56,。

                76,7,7,2,1,。

                45,4,6,7,8];。

    //var array = [4,2,5,1,0,3];。

    array = sorting.shellSort(array);。

    alert(array);。

var sorting = {。

    //利用sort方法进行排序。

    systemSort: function(arr){。

        return arr.sort(function(a,b){。

            return a-b;。

        });

    },

    //冒泡排序

    bubbleSort: function(arr){。

        var len=arr.length, tmp;。

        for(var i=0;i<len-1;i++){。

            for(var j=0;j<len-1-i;j++){。

                if(arr[j]>arr[j+1]){。

                    tmp = arr[j];。

                    arr[j] = arr[j+1];。

                    arr[j+1] = tmp;。

                }。

            }

        }

        return arr;。

    },

    //快速排序

    quickSort: function(arr){。

        var low=0, high=arr.length-1;。

        sort(low,high);。

        function sort(low, high){。

            if(low<high){。

                var mid = (function(low, high){。

                    var tmp = arr[low];。

                    while(low<high){。

                        while(low<high&&arr[high]>=tmp){。

                            high--;。

                        }。

                        arr[low] = arr[high];。

                        while(low<high&&arr[low]<=tmp){。

                            low++;。

                        }。

                        arr[high] = arr[low];。

                    }。

                    arr[low] = tmp;。

                    return low;。

                })(low, high);。

                sort(low, mid-1);。

                sort(mid+1,high);。

            }

        }

        return arr;。

    },

    //插入排序

    insertSort: function(arr){。

        var len = arr.length;。

        for(var i=1;i<len;i++){。

            var tmp = arr[i];。

            for(var j=i-1;j>=0;j--){。

                if(tmp<arr[j]){。

                    arr[j+1] = arr[j];。

                }else{。

                    arr[j+1] = tmp;。

                    break;。

                }。

            }

        }

        return arr;。

    },

    //希尔排序

    shellSort: function(arr){。

        console.log(arr);。

        var h = 1;。

        while(h<=arr.length/3){。

            h = h*3+1;  //O(n^(3/2))by Knuth,1973。

        }

        for( ;h>=1;h=Math.floor(h/3)){。

            for(var k=0;k<h;k++){。

                for(var i=h+k;i<arr.length;i+=h){。

                    for(var j=i;j>=h&&arr[j]<arr[j-h];j-=h){。

                        var tmp = arr[j];。

                        arr[j] = arr[j-h];。

                        arr[j-h] = tmp;。

                    }。

                }。

            }

        }

        return arr;。

    }

记录下js几种常见的数组排序和去重的方法

排序，从小大，0坐标的在下面，即排序后小的在下面，大的在上面。

1，冒泡Bubble：从第0个开始，一直往上，与相邻的元素比较，如果下面的大，则交换。

Analysis：

Implementation：

void BubbleSort(int *pData, int iNum)。

2，插入Insertion：与打扑克牌时整理牌很想象，假定第一张牌是有序的，从第二张牌开始，拿出这张牌来，往下比较，如果有比这张牌大的，则把它拨到上一个位置，直到找到比手上的这张更小的（或到顶了），

则把手上的这张牌插入到这张更小的牌的后面。

Analysis：

Implementation：

void InsertionSort(int *list, int length)。

int i, j, temp;。

for (i = 1; i < length; i++)。

{

temp = list[i];。

j = i - 1;。

while ((j >= 0) && (list[j] > temp))。

{

list[j+1] = list[j];。

j--;。

}

list[j+1] = temp;。

}

3，选择Selection：从所有元素中找到最小的放在0号位置，从其它元素（除了0号元素）中再找到最小的，放到1号位置，......。

Analysis：

Implementation：

void SelectionSort(int data[], int count)。

int i, j, min, temp;。

for (i = 0; i < count - 1; i++) 。

{

/* find the minimum */。

min = i;。

for (j = i+1; j < count; j++)。

{

if (data[j] < data[min])。

{

min = j;。

}

}

/* swap data[i] and data[min] */。

temp = data[i];。

data[i] = data[min];。

data[min] = temp;。

}

4，快速Quick：先拿出中间的元素来（值保存到temp里），设置两个索引（index or pointer），一个从0号位置开始往最大位置寻找比temp大的元素；一个从最大号位置开始往最小位置寻找比temp小的元素，找到了或到顶了，则将两个索引所指向的元素。

互换，如此一直寻找交换下去，直到两个索引交叉了位置，这个时候，从0号位置到第二个索引的所有元素就都比temp小，从第一个索引到最大位置的所有元素就都比temp大，这样就把所有元素分为了两块，然后采用前面的办法分别排序这两个部分。总的来。

说，就是随机找一个元素（通常是中间的元素），然后把小的放在它的左边，大的放右边，对左右两边的数据继续采用同样的办法。只是为了节省空间，上面采用了左右交换的方法来达到目的。

Analysis：

Implementation：

void QuickSort(int *pData, int left, int right)。

int i, j;

int middle, iTemp;。

i = left;

j = right;

middle = pData[(left + right) / 2]; //求中间值。

do

{

while ((pData[i] < middle) && (i < right)) //从左扫描大于中值的数。

i++;。

while ((pData[j] > middle) && (j > left)) //从右扫描小于中值的数。

j--;。

if (i <= j) //找到了一对值。

{

//交换。

iTemp = pData[i];。

pData[i] = pData[j];。

pData[j] = iTemp;。

i++;。

j--;。

}

} while (i <= j); //如果两边扫描的下标交错，就停止（完成一次）

//当左边部分有值(left<j)，递归左半边。

if(left < j) 。

QuickSort(pData, left, j); 。

//当右边部分有值(right>i)，递归右半边。

if(right > i) 。

QuickSort(pData, i, right); 。

5，希尔Shell：是对Insertion Sort的一种改进，在Insertion Sort中，从第2个位置开始取出数据，每次都是与前一个（step/gap==1）进行比较。Shell Sort修改为，在开始时采用较大的步长step，

从第step位置开始取数据，每次都与它的前step个位置上的数据进行比较（如果有8个数据，初始step==4，那么pos(4)与pos(0)比较，pos(0)与pos(-4)，pos(5)与pos(1)，pos(1)与pos(-3)，

...... pos(7)与pos(3)，pos(3)与pos(-1)），然后逐渐地减小step，直到step==1。step==1时，排序过程与Insertion Sort一样，但因为有前面的排序，这次排序将减少比较和交换的次数。

Shell Sort的时间复杂度与步长step的选择有很大的关系。Shell排序比冒泡排序快5倍，比插入排序大致快2倍。Shell排序比起QuickSort，MergeSort，HeapSort慢很多。但是它相对比较简单，它适合。

于数据量在5000以下并且速度并不是特别重要的场合。它对于数据量较小的数列重复排序是非常好的。

Analysis：

Implementation：

template<typename RandomIter, typename Compare>。

void ShellSort(RandomIter begin, RandomIter end, Compare cmp)。

typedef typename std::iterator_traits<RandomIter>::value_type value_type;。

typedef typename std::iterator_traits<RandomIter>::difference_type diff_t;。

diff_t size = std::distance(begin, end);。

diff_t step = size / 2;。

while (step >= 1)。

{

for (diff_t i = step; i < size; ++i)。

{

value_type key = *(begin+i);。

diff_t ins = i; // current position。

while (ins >= step && cmp(key, *(begin+ins-step)))。

{

*(begin+ins) = *(begin+ins-step);。

ins -= step;。

}

*(begin+ins) = key;。

}

if(step == 2)。

step = 1;。

else

step = static_cast<diff_t>(step / 2.2);。

}

template<typename RandomIter>。

void ShellSort(RandomIter begin, RandomIter end) 。

typedef typename std::iterator_traits<RandomIter>::value_type value_type;。

ShellSort(begin, end, std::less<value_type>());。

6，归并Merge：先将所有数据分割成单个的元素，这个时候单个元素都是有序的，然后前后相邻的两个两两有序地合并，合并后的这两个数据再与后面的两个合并后的数据再次合并，充分前面的过程直到所有的数据都合并到一块。

通常在合并的时候需要分配新的内存。

Analysis：

Implementation：

void Merge(int array[], int low, int mid, int high)。

int k;

int *temp = (int *) malloc((high-low+1) * sizeof(int)); //申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列。

int begin1 = low;。

int end1 = mid;。

int begin2 = mid + 1;。

int end2 = high;。

for (k = 0; begin1 <= end1 && begin2 <= end2; ++k) //比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置。

{

if(array[begin1]<=array[begin2])。

{

temp[k] = array[begin1++];。

}

else

{

temp[k] = array[begin2++];。

}

}

if(begin1 <= end1) //若第一个序列有剩余，直接拷贝出来粘到合并序列尾。

{

memcpy(temp+k, array+begin1, (end1-begin1+1)*sizeof(int));。

}

if(begin2 <= end2) //若第二个序列有剩余，直接拷贝出来粘到合并序列尾。

{

memcpy(temp+k, array+begin2, (end2-begin2+1)*sizeof(int));。

}

memcpy(array+low, temp, (high-low+1)*sizeof(int));//将排序好的序列拷贝回数组中。

free(temp);。

void MergeSort(int array[], unsigned int first, unsigned int last)。

int mid = 0;。

if (first < last)。

{

mid = (first+last)/2;。

MergeSort(array, first, mid);。

MergeSort(array, mid+1,last);。

Merge(array,first,mid,last);。

}

JavaScript数字数组怎么按数子大小排序

js 数组去重

注：应该也可以适用于 object数组，但是本人没有进行验证，贴出来仅供你参考。

第一种是比较常规的方法思路：1.构建一个新的数组存放结果2.for循环中每次从原数组中取出一个元素，用这个元素循环与结果数组对比3.若结果数组中没有该元素，则存到结果数组中代码如下:。

Array.prototype.unique1 = function(){ var res = [this[0]]; for(var i = 1; i < this.length; i++){ var repeat = false; for(var j = 0; j < res.length; j++){ if(this[i] == res[j]){ repeat = true; break; } } if(!repeat){ res.push(this[i]); } } return res;}var arr = [1, 'a', 'a', 'b', 'd', 'e', 'e', 1, 0]alert(arr.unique1());。

第二种方法比上面的方法效率要高思路：1.先将原数组进行排序2.检查原数组中的第i个元素 与 结果数组中的最后一个元素是否相同，因为已经排序，所以重复元素会在相邻位置3.如果不相同，则将该元素存入结果数组中代码如下：

Array.prototype.unique2 = function(){ this.sort(); //先排序 var res = [this[0]]; for(var i = 1; i < this.length; i++){ if(this[i] !== res[res.length - 1]){ res.push(this[i]); } } return res;}var arr = [1, 'a', 'a', 'b', 'd', 'e', 'e', 1, 0]alert(arr.unique2());。

二种方法也会有一定的局限性，因为在去重前进行了排序，所以最后返回的去重结果也是排序后的。如果要求不改变数组的顺序去重，那这种方法便不可取了。第三种方法（推荐使用）思路：1.创建一个新的数组存放结果2.创建一个空对象3.for循环时，每次取出一个元素与对象进行对比，如果这个元素不重复，则把它存放到结果数组中，同时把这个元素的内容作为对象的一个属性，并赋值为1，存入到第2步建立的对象中。说明：至于如何对比，就是每次从原数组中取出一个元素，然后到对象中去访问这个属性，如果能访问到值，则说明重复。代码如下：

Array.prototype.unique3 = function(){ var res = []; var json = {}; for(var i = 0; i < this.length; i++){ if(!json[this[i]]){ res.push(this[i]); json[this[i]] = 1; } } return res;}var arr = [112,112,34,'你好',112,112,34,'你好','str','str1'];alert(arr.unique3());。

原文地址：http://www.qianchusai.com/%E6%95%B0%E7%BB%84%E6%8E%92%E5%BA%8Fjs.html