JS-几大排序算法（更新中...）

关于排序都会讲的名词：（我自己的理解）

　　时间复杂度：　　指排序过程中，程序消耗的时间。

　　空间复杂度：　　指排序过程中，程序所消耗内存的大小。

　　　　　稳定：　　如果两个值相等，a和b，a=b且a在b位置的左边，排序后依旧在左边(或者上下排列的话，可以理解为前边)。

　　　　不稳定：　　两个相等的值在一起，排序会让其互换位置。

关于稳定和不稳定，有图说明：

如上图一：北京成都、上海广州，这两对，值相等，分别都是90和50，北京在成都的前边吧，

如上图二：排序后，按大小顺序排列，但是之前成都在后边，现在跑到北京的前边了。

如上图三：再次点击排序按钮，西安和呼和浩特分别是最大最小没有动，但是北京成都、上海广州这两对互换了位置

这就是不稳定。

如果不互换，按照图一的位置，最终的排序应该是：西、北、成、上、广、呼。且无论后期点多少次排序，都将是这个顺序才是。

一、冒泡排序

源代码:

var arrData=[12,35,23,18,95,2,67,9,56];
sortArr(arrData);

function sortArr(arr){
     for(i=0;i<arr.length-1;i++){
         for(j=0;j<arr.length-1-i;j++){
           if(arr[j]>arr[j+1]){
               var temp=arr[j];
               arr[j]=arr[j+1];
               arr[j+1]=temp;
            }
         }
    }
    return arr;
} 

分析用的代码：

 var arrData=[12,35,23,18,95,2,67,9,56];
 sortArr(arrData);

 function sortArr(arr){
             for(i=0;i<arr.length-1;i++){
                 console.log("i="+i+",下标对应数为"+arr[i]+",大循环 "+(i+1));
                 for(j=0;j<arr.length-1-i;j++){
                         console.log("j="+j+",下标对应数为"+arr[j]+",小循环"+(i+1)+"-"+(j+1));
                         console.log("j+1对应的数是"+arr[j+1]);
                         console.log(arr[j]+"和"+arr[j+1]+"比");
                     if(arr[j]>arr[j+1]){
                             console.log(arr[j]+"大于"+arr[j+1]+"，互换位置");
                         var temp=arr[j];
                         console.log("先把"+arr[j]+"存到temp中");
                         arr[j]=arr[j+1];
                         console.log("再让"+arr[j]+"等于后边比他小的"+arr[j+1]);
                         arr[j+1]=temp;
                         console.log("最后把存在temp中前边较大的值"+temp+"给了后边的arr[j+1]");
                     }else{
                         console.log(arr[j]+"小于"+arr[j+1]+"，跳过本次循环");
                     }
                 }
             }
             return arr;
         }

分析代码

排序过程中，文字描述

输出结果：[2, 9, 12, 18, 23, 35, 56, 67, 95];
初始值对比：[12,35,23,18,95,2,67,9,56];

 i=0,下标对应数为12,大循环 1
 j=0,下标对应数为12,小循环1-1
 j+1对应的数是35
 12和35比
 12小于35，跳过本次循环
 j=1,下标对应数为35,小循环1-2
 j+1对应的数是23
 35和23比
 35大于23，互换位置
 先把35存到temp中
 再让前边的大值35等于后边比他小的23
 最后把存在temp中前边较大的值35给了后边的arr[j+1]
 调换23与35的顺序完成
 j=2,下标对应数为35,小循环1-3
 j+1对应的数是18
 35和18比
 35大于18，互换位置
 先把35存到temp中
 再让前边的大值35等于后边比他小的18
 最后把存在temp中前边较大的值35给了后边的arr[j+1]
 调换18与35的顺序完成
 j=3,下标对应数为35,小循环1-4
 j+1对应的数是95
 35和95比
 35小于95，跳过本次循环
 j=4,下标对应数为95,小循环1-5
 j+1对应的数是2
 95和2比
 95大于2，互换位置
 先把95存到temp中
 再让前边的大值95等于后边比他小的2
 最后把存在temp中前边较大的值95给了后边的arr[j+1]
 调换2与95的顺序完成
 j=5,下标对应数为95,小循环1-6
 j+1对应的数是67
 95和67比
 95大于67，互换位置
 先把95存到temp中
 再让前边的大值95等于后边比他小的67
 最后把存在temp中前边较大的值95给了后边的arr[j+1]
 调换67与95的顺序完成
 j=6,下标对应数为95,小循环1-7
 j+1对应的数是9
 95和9比
 95大于9，互换位置
 先把95存到temp中
 再让前边的大值95等于后边比他小的9
 最后把存在temp中前边较大的值95给了后边的arr[j+1]
 调换9与95的顺序完成
 j=7,下标对应数为95,小循环1-8
 j+1对应的数是56
 95和56比
 95大于56，互换位置
 先把95存到temp中
 再让前边的大值95等于后边比他小的56
 最后把存在temp中前边较大的值95给了后边的arr[j+1]
 调换56与95的顺序完成
 i=1,下标对应数为23,大循环 2
 j=0,下标对应数为12,小循环2-1
 j+1对应的数是23
 12和23比
 12小于23，跳过本次循环
 j=1,下标对应数为23,小循环2-2
 j+1对应的数是18
 23和18比
 23大于18，互换位置
 先把23存到temp中
 再让前边的大值23等于后边比他小的18
 最后把存在temp中前边较大的值23给了后边的arr[j+1]
 调换18与23的顺序完成
 j=2,下标对应数为23,小循环2-3
 j+1对应的数是35
 23和35比
 23小于35，跳过本次循环
 j=3,下标对应数为35,小循环2-4
 j+1对应的数是2
 35和2比
 35大于2，互换位置
 先把35存到temp中
 再让前边的大值35等于后边比他小的2
 最后把存在temp中前边较大的值35给了后边的arr[j+1]
 调换2与35的顺序完成
 j=4,下标对应数为35,小循环2-5
 j+1对应的数是67
 35和67比
 35小于67，跳过本次循环
 j=5,下标对应数为67,小循环2-6
 j+1对应的数是9
 67和9比
 67大于9，互换位置
 先把67存到temp中
 再让前边的大值67等于后边比他小的9
 最后把存在temp中前边较大的值67给了后边的arr[j+1]
 调换9与67的顺序完成
 j=6,下标对应数为67,小循环2-7
 j+1对应的数是56
 67和56比
 67大于56，互换位置
 先把67存到temp中
 再让前边的大值67等于后边比他小的56
 最后把存在temp中前边较大的值67给了后边的arr[j+1]
 调换56与67的顺序完成
 i=2,下标对应数为23,大循环 3
 j=0,下标对应数为12,小循环3-1
 j+1对应的数是18
 12和18比
 12小于18，跳过本次循环
 j=1,下标对应数为18,小循环3-2
 j+1对应的数是23
 18和23比
 18小于23，跳过本次循环
 j=2,下标对应数为23,小循环3-3
 j+1对应的数是2
 23和2比
 23大于2，互换位置
 先把23存到temp中
 再让前边的大值23等于后边比他小的2
 最后把存在temp中前边较大的值23给了后边的arr[j+1]
 调换2与23的顺序完成
 j=3,下标对应数为23,小循环3-4
 j+1对应的数是35
 23和35比
 23小于35，跳过本次循环
 j=4,下标对应数为35,小循环3-5
 j+1对应的数是9
 35和9比
 35大于9，互换位置
 先把35存到temp中
 再让前边的大值35等于后边比他小的9
 最后把存在temp中前边较大的值35给了后边的arr[j+1]
 调换9与35的顺序完成
 j=5,下标对应数为35,小循环3-6
 j+1对应的数是56
 35和56比
 35小于56，跳过本次循环
 i=3,下标对应数为23,大循环 4
 j=0,下标对应数为12,小循环4-1
 j+1对应的数是18
 12和18比
 12小于18，跳过本次循环
 j=1,下标对应数为18,小循环4-2
 j+1对应的数是2
 18和2比
 18大于2，互换位置
 先把18存到temp中
 再让前边的大值18等于后边比他小的2
 最后把存在temp中前边较大的值18给了后边的arr[j+1]
 调换2与18的顺序完成
 j=2,下标对应数为18,小循环4-3
 j+1对应的数是23
 18和23比
 18小于23，跳过本次循环
 j=3,下标对应数为23,小循环4-4
 j+1对应的数是9
 23和9比
 23大于9，互换位置
 先把23存到temp中
 再让前边的大值23等于后边比他小的9
 最后把存在temp中前边较大的值23给了后边的arr[j+1]
 调换9与23的顺序完成
 j=4,下标对应数为23,小循环4-5
 j+1对应的数是35
 23和35比
 23小于35，跳过本次循环
 i=4,下标对应数为23,大循环 5
 j=0,下标对应数为12,小循环5-1
 j+1对应的数是2
 12和2比
 12大于2，互换位置
 先把12存到temp中
 再让前边的大值12等于后边比他小的2
 最后把存在temp中前边较大的值12给了后边的arr[j+1]
 调换2与12的顺序完成
 j=1,下标对应数为12,小循环5-2
 j+1对应的数是18
 12和18比
 12小于18，跳过本次循环
 j=2,下标对应数为18,小循环5-3
 j+1对应的数是9
 18和9比
 18大于9，互换位置
 先把18存到temp中
 再让前边的大值18等于后边比他小的9
 最后把存在temp中前边较大的值18给了后边的arr[j+1]
 调换9与18的顺序完成
 j=3,下标对应数为18,小循环5-4
 j+1对应的数是23
 18和23比
 18小于23，跳过本次循环
 i=5,下标对应数为35,大循环 6
 j=0,下标对应数为2,小循环6-1
 j+1对应的数是12
 2和12比
 2小于12，跳过本次循环
 j=1,下标对应数为12,小循环6-2
 j+1对应的数是9
 12和9比
 12大于9，互换位置
 先把12存到temp中
 再让前边的大值12等于后边比他小的9
 最后把存在temp中前边较大的值12给了后边的arr[j+1]
 调换9与12的顺序完成
 j=2,下标对应数为12,小循环6-3
 j+1对应的数是18
 12和18比
 12小于18，跳过本次循环
 i=6,下标对应数为56,大循环 7
 j=0,下标对应数为2,小循环7-1
 j+1对应的数是9
 2和9比
 2小于9，跳过本次循环
 j=1,下标对应数为9,小循环7-2
 j+1对应的数是12
 9和12比
 9小于12，跳过本次循环
 i=7,下标对应数为67,大循环 8
 j=0,下标对应数为2,小循环8-1
 j+1对应的数是9
 2和9比
 2小于9，跳过本次循环
 输出结果：[2, 9, 12, 18, 23, 35, 56, 67, 95];
 初始值对比：[12,35,23,18,95,2,67,9,56];

文字描述冒泡排序的全过程

原理：

第一遍循环，在内循环里把最大的数拍到了最后。

第二遍循环i，在内循环里，排除掉最后一个最大的不循环，将剩下的再次循环，把次要大的排到最后。

最终，出来从大到小的循环。

再循环里边，让当前循环到的数和后一个比较，若小于不动位置，若大于，则将这个数先存到temp中，然后让这个数等于后一个数，再让后一个数等于temp，完成两个数的位置调换。

依次类推，最后比后一个数大的数，都被移到了最后。

若变成从大到小的循环：

只需把  if(arr[j]>arr[j+1])  处的大于号换成小于号即可。