zoukankan      html  css  js  c++  java
  • 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;
    } 

    分析用的代码:

     1 var arrData=[12,35,23,18,95,2,67,9,56];
     2 sortArr(arrData);
     3 
     4 function sortArr(arr){
     5             for(i=0;i<arr.length-1;i++){
     6                 console.log("i="+i+",下标对应数为"+arr[i]+",大循环 "+(i+1));
     7                 for(j=0;j<arr.length-1-i;j++){
     8                         console.log("j="+j+",下标对应数为"+arr[j]+",小循环"+(i+1)+"-"+(j+1));
     9                         console.log("j+1对应的数是"+arr[j+1]);
    10                         console.log(arr[j]+"和"+arr[j+1]+"比");
    11                     if(arr[j]>arr[j+1]){
    12                             console.log(arr[j]+"大于"+arr[j+1]+",互换位置");
    13                         var temp=arr[j];
    14                         console.log("先把"+arr[j]+"存到temp中");
    15                         arr[j]=arr[j+1];
    16                         console.log("再让"+arr[j]+"等于后边比他小的"+arr[j+1]);
    17                         arr[j+1]=temp;
    18                         console.log("最后把存在temp中前边较大的值"+temp+"给了后边的arr[j+1]");
    19                     }else{
    20                         console.log(arr[j]+"小于"+arr[j+1]+",跳过本次循环");
    21                     }
    22                 }
    23             }
    24             return arr;
    25         }
    分析代码

    排序过程中,文字描述 

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

      1 i=0,下标对应数为12,大循环 1
      2 j=0,下标对应数为12,小循环1-1
      3 j+1对应的数是35
      4 12和35比
      5 12小于35,跳过本次循环
      6 j=1,下标对应数为35,小循环1-2
      7 j+1对应的数是23
      8 35和23比
      9 35大于23,互换位置
     10 先把35存到temp中
     11 再让前边的大值35等于后边比他小的23
     12 最后把存在temp中前边较大的值35给了后边的arr[j+1]
     13 调换23与35的顺序完成
     14 j=2,下标对应数为35,小循环1-3
     15 j+1对应的数是18
     16 35和18比
     17 35大于18,互换位置
     18 先把35存到temp中
     19 再让前边的大值35等于后边比他小的18
     20 最后把存在temp中前边较大的值35给了后边的arr[j+1]
     21 调换18与35的顺序完成
     22 j=3,下标对应数为35,小循环1-4
     23 j+1对应的数是95
     24 35和95比
     25 35小于95,跳过本次循环
     26 j=4,下标对应数为95,小循环1-5
     27 j+1对应的数是2
     28 95和2比
     29 95大于2,互换位置
     30 先把95存到temp中
     31 再让前边的大值95等于后边比他小的2
     32 最后把存在temp中前边较大的值95给了后边的arr[j+1]
     33 调换2与95的顺序完成
     34 j=5,下标对应数为95,小循环1-6
     35 j+1对应的数是67
     36 95和67比
     37 95大于67,互换位置
     38 先把95存到temp中
     39 再让前边的大值95等于后边比他小的67
     40 最后把存在temp中前边较大的值95给了后边的arr[j+1]
     41 调换67与95的顺序完成
     42 j=6,下标对应数为95,小循环1-7
     43 j+1对应的数是9
     44 95和9比
     45 95大于9,互换位置
     46 先把95存到temp中
     47 再让前边的大值95等于后边比他小的9
     48 最后把存在temp中前边较大的值95给了后边的arr[j+1]
     49 调换9与95的顺序完成
     50 j=7,下标对应数为95,小循环1-8
     51 j+1对应的数是56
     52 95和56比
     53 95大于56,互换位置
     54 先把95存到temp中
     55 再让前边的大值95等于后边比他小的56
     56 最后把存在temp中前边较大的值95给了后边的arr[j+1]
     57 调换56与95的顺序完成
     58 i=1,下标对应数为23,大循环 2
     59 j=0,下标对应数为12,小循环2-1
     60 j+1对应的数是23
     61 12和23比
     62 12小于23,跳过本次循环
     63 j=1,下标对应数为23,小循环2-2
     64 j+1对应的数是18
     65 23和18比
     66 23大于18,互换位置
     67 先把23存到temp中
     68 再让前边的大值23等于后边比他小的18
     69 最后把存在temp中前边较大的值23给了后边的arr[j+1]
     70 调换18与23的顺序完成
     71 j=2,下标对应数为23,小循环2-3
     72 j+1对应的数是35
     73 23和35比
     74 23小于35,跳过本次循环
     75 j=3,下标对应数为35,小循环2-4
     76 j+1对应的数是2
     77 35和2比
     78 35大于2,互换位置
     79 先把35存到temp中
     80 再让前边的大值35等于后边比他小的2
     81 最后把存在temp中前边较大的值35给了后边的arr[j+1]
     82 调换2与35的顺序完成
     83 j=4,下标对应数为35,小循环2-5
     84 j+1对应的数是67
     85 35和67比
     86 35小于67,跳过本次循环
     87 j=5,下标对应数为67,小循环2-6
     88 j+1对应的数是9
     89 67和9比
     90 67大于9,互换位置
     91 先把67存到temp中
     92 再让前边的大值67等于后边比他小的9
     93 最后把存在temp中前边较大的值67给了后边的arr[j+1]
     94 调换9与67的顺序完成
     95 j=6,下标对应数为67,小循环2-7
     96 j+1对应的数是56
     97 67和56比
     98 67大于56,互换位置
     99 先把67存到temp中
    100 再让前边的大值67等于后边比他小的56
    101 最后把存在temp中前边较大的值67给了后边的arr[j+1]
    102 调换56与67的顺序完成
    103 i=2,下标对应数为23,大循环 3
    104 j=0,下标对应数为12,小循环3-1
    105 j+1对应的数是18
    106 12和18比
    107 12小于18,跳过本次循环
    108 j=1,下标对应数为18,小循环3-2
    109 j+1对应的数是23
    110 18和23比
    111 18小于23,跳过本次循环
    112 j=2,下标对应数为23,小循环3-3
    113 j+1对应的数是2
    114 23和2比
    115 23大于2,互换位置
    116 先把23存到temp中
    117 再让前边的大值23等于后边比他小的2
    118 最后把存在temp中前边较大的值23给了后边的arr[j+1]
    119 调换2与23的顺序完成
    120 j=3,下标对应数为23,小循环3-4
    121 j+1对应的数是35
    122 23和35比
    123 23小于35,跳过本次循环
    124 j=4,下标对应数为35,小循环3-5
    125 j+1对应的数是9
    126 35和9比
    127 35大于9,互换位置
    128 先把35存到temp中
    129 再让前边的大值35等于后边比他小的9
    130 最后把存在temp中前边较大的值35给了后边的arr[j+1]
    131 调换9与35的顺序完成
    132 j=5,下标对应数为35,小循环3-6
    133 j+1对应的数是56
    134 35和56比
    135 35小于56,跳过本次循环
    136 i=3,下标对应数为23,大循环 4
    137 j=0,下标对应数为12,小循环4-1
    138 j+1对应的数是18
    139 12和18比
    140 12小于18,跳过本次循环
    141 j=1,下标对应数为18,小循环4-2
    142 j+1对应的数是2
    143 18和2比
    144 18大于2,互换位置
    145 先把18存到temp中
    146 再让前边的大值18等于后边比他小的2
    147 最后把存在temp中前边较大的值18给了后边的arr[j+1]
    148 调换2与18的顺序完成
    149 j=2,下标对应数为18,小循环4-3
    150 j+1对应的数是23
    151 18和23比
    152 18小于23,跳过本次循环
    153 j=3,下标对应数为23,小循环4-4
    154 j+1对应的数是9
    155 23和9比
    156 23大于9,互换位置
    157 先把23存到temp中
    158 再让前边的大值23等于后边比他小的9
    159 最后把存在temp中前边较大的值23给了后边的arr[j+1]
    160 调换9与23的顺序完成
    161 j=4,下标对应数为23,小循环4-5
    162 j+1对应的数是35
    163 23和35比
    164 23小于35,跳过本次循环
    165 i=4,下标对应数为23,大循环 5
    166 j=0,下标对应数为12,小循环5-1
    167 j+1对应的数是2
    168 12和2比
    169 12大于2,互换位置
    170 先把12存到temp中
    171 再让前边的大值12等于后边比他小的2
    172 最后把存在temp中前边较大的值12给了后边的arr[j+1]
    173 调换2与12的顺序完成
    174 j=1,下标对应数为12,小循环5-2
    175 j+1对应的数是18
    176 12和18比
    177 12小于18,跳过本次循环
    178 j=2,下标对应数为18,小循环5-3
    179 j+1对应的数是9
    180 18和9比
    181 18大于9,互换位置
    182 先把18存到temp中
    183 再让前边的大值18等于后边比他小的9
    184 最后把存在temp中前边较大的值18给了后边的arr[j+1]
    185 调换9与18的顺序完成
    186 j=3,下标对应数为18,小循环5-4
    187 j+1对应的数是23
    188 18和23比
    189 18小于23,跳过本次循环
    190 i=5,下标对应数为35,大循环 6
    191 j=0,下标对应数为2,小循环6-1
    192 j+1对应的数是12
    193 2和12比
    194 2小于12,跳过本次循环
    195 j=1,下标对应数为12,小循环6-2
    196 j+1对应的数是9
    197 12和9比
    198 12大于9,互换位置
    199 先把12存到temp中
    200 再让前边的大值12等于后边比他小的9
    201 最后把存在temp中前边较大的值12给了后边的arr[j+1]
    202 调换9与12的顺序完成
    203 j=2,下标对应数为12,小循环6-3
    204 j+1对应的数是18
    205 12和18比
    206 12小于18,跳过本次循环
    207 i=6,下标对应数为56,大循环 7
    208 j=0,下标对应数为2,小循环7-1
    209 j+1对应的数是9
    210 2和9比
    211 2小于9,跳过本次循环
    212 j=1,下标对应数为9,小循环7-2
    213 j+1对应的数是12
    214 9和12比
    215 9小于12,跳过本次循环
    216 i=7,下标对应数为67,大循环 8
    217 j=0,下标对应数为2,小循环8-1
    218 j+1对应的数是9
    219 2和9比
    220 2小于9,跳过本次循环
    221 输出结果:[2, 9, 12, 18, 23, 35, 56, 67, 95];
    222 初始值对比:[12,35,23,18,95,2,67,9,56];
    文字描述冒泡排序的全过程

     原理:

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

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

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

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

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

    若变成从大到小的循环:

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

  • 相关阅读:
    flex + bison multiple parsers
    Educational Codeforces Round 95 (Rated for Div. 2)
    python学习笔记 day20 序列化模块(二)
    python学习笔记 day20 常用模块(六)
    python 学习笔记 常用模块(五)
    python学习笔记 day19 常用模块(四)
    python学习笔记 day19 常用模块(三)
    python学习笔记 day19 常用模块(二)
    python学习笔记 day19 作业讲解-使用正则表达式实现计算器
    python学习笔记 day19 常用模块
  • 原文地址:https://www.cnblogs.com/padding1015/p/7659635.html
Copyright © 2011-2022 走看看