js 常用排序收拾分分快三计划

作者:编程技术
def select_sort(list):
    n=len(list)
    #进行n-1次操作
    for i in range(n-1):
        min_dex=i
        #记录最小的位置
        for j in range(i 1,n):
            #从i 1选取最小位置
            if list[j]<list[min_dex]:
                min_dex=j
        #最小位置不对应进行交换
        if min_dex !=i:
            list[i],list[min_dex]=list[min_dex],list[i]
List=[0,3,1,2,9,4,6,5,8,7]
select_sort(List)
print(List)

敏捷排序

筛选排序(select_sort卡塔尔国是二个底工排序,它至关心注重要透过查找已给连串中的成分的最大依然最小成分,然后将其坐落种类的原初地方依然终止地方,并透过屡次如此的大循环完结对已知种类的排序,在咱们对n个成分举办操作时,大家起码须要n-1次。

接纳排序

以此算法也很简短,每趟都把未排序体系里最小(大卡塔 尔(英语:State of Qatar)的选出来,放在系列。

  1. 大器晚成趟遍历未排序系列,选出最小(大卡塔尔的数字;
  2. 把那个数字放在未排序系列前边,*未排序种类 1
  3. 双重步骤到造成排序。

代码达成:

int []a = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};

        for (int i = 0; i<a.length;i  ){
            int min = a[i];
            int mark = i;
            for(int j = i ;j <a.length ; j  ){
                if( min > a[j]) 
                    {
                        min = a[j];
                        mark = j;
                    }
            }
            int temp = a[i];
            a[i] = min;
            a[mark] = temp;

        }

 修正版(定义标识变量记录每一遍最终一遍调换的地点索引,此标志变量之后的因素皆已经换来完结,故再度循环的时候只实行到标志变量的任务比较就能够卡塔尔

冒泡排序

简单的讲的说便是,每叁回遍历都把最大(小)的经过比较选出来。

  1. 从第一个元素起头比较相邻的七个因素,把大(小卡塔 尔(阿拉伯语:قطر‎的未来移;
  2. 相比较到未排序的终极一个要素时,会吸收那趟冒泡获得的最大(小卡塔尔成分;
  3. 直白遍历到独有贰个成分

代码实现:

(java)
int []a = {5,4,3,2,1,12,32,13,24,53};

        for (int i = a.length - 1 ; i >0; i--){
            for (int j = 0;j< i;j  ){
                if(a[j] > a[j 1])
                {
                    int temp = a[j];
                    a[j] = a[j 1];
                    a[j 1] = temp;
                }
            }
        }
 1             function mergeSort(array) {
 2             if (array.length < 2) {
 3                 return array;
 4             }
 5             const middle = parseInt(array.length / 2);
 6             const left = array.slice(0, middle);
 7             const right = array.slice(middle);
 8             return merge(mergeSort(left), mergeSort(right));
 9         }
10         function merge(left, right) {
11             const newArray = [];
12             while (left.length && right.length) {
13                 if (left[0] <= right[0]) {
14                     newArray.push(left.shift());
15                 } else {
16                     newArray.push(right.shift());
17                 }
18             }
19             while (left.length) {
20                 newArray.push(left.shift());
21             }
22             while (right.length) {
23                 newArray.push(right.shift());
24             }
25             return newArray;
26         }

排序算法

  • 冒泡(Bubble)
  • 选择
  • 插入
  • 归并
  • 快速
  • 计数排序

利口酒(定向冒泡排序)(从高位到未有的同有时候也从未有到高位卡塔尔

插入排序

排序流程:

  1. 从第贰个成分开首,该因素得以感到曾经被排序
  2. 抽出下一个成分,在已经排序的因素连串中从后迈入扫描
  3. 比方被围观的因素(已排序卡塔尔国大于新因素,将该因素后移一个人
  4. 双重步骤 3,直到找到已排序的成分小于只怕等于新因素的岗位
  5. 将新成分插入到该职位后
  6. 双重步骤 2~5

兑今世码:

package Sort;

public class InsertSort {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int []a = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};

        for (int i = 1;i<a.length;i  ){
            int temp = a[i];
            for (int j = i - 1 ; j>=0 ; j--){
                if(temp < a[j]){
                    a[j 1] = a[j];
                    a[j] = temp;

                }else{
                    break;
                }
            }

        }

        for (int i = 0 ; i< a.length ; i  )
            System.out.print(a[i] " ");
    }

}

    (2). 插入排序:
      1). 间接插入排序 稳固
        1. 取冬天体系的率先个特别有序系列
        2. 从第三个起来抓取,从静止类别的末段起头向前找
        3. 要是 相比较到的因素(有序种类中的成分)(array[j]) > 被相比较的要素(要插入的要素)(key),则 将前者向后活动叁个职位(array[j 1] = array[j])
        4. 假若 相比到的因素(有序类别中的成分)(array[j]) >= 被比较的要素(要插入的要素)(key),则 将后面一个放置前面二个的下三个地方处(array[j 1] = key)

合并列排在一条线序

合并列排在一条线序选取呢,采用了分治法来让多少个数组合并。

排序流程:

  1. 申请空间,使其尺寸为七个已经排序系列之和,该空间用来存放在合併后的类别
  2. 设定七个指针,最先地点分别为七个曾经排序种类的苗子地点
  3. 相比比较多个指针所针没有错要素,接纳相对小的要素放入到统风流洒脱空间,并活动指针到下大器晚成岗位
  4. 再也步骤 3 直到某一指针达到连串尾
  5. 将另大器晚成体系剩下的有着因素直接复制到归总系列尾
public static int[] sort(int[] nums, int low, int high) {  
        int mid = (low   high) / 2;  
        if (low < high) {  
            // 左边  
            sort(nums, low, mid);  
            // 右边  
            sort(nums, mid   1, high);  
            // 左右归并  
            merge(nums, low, mid, high);  
        }  
        return nums;  
    }  

    public static void merge(int[] nums, int low, int mid, int high) {  
        int[] temp = new int[high - low   1];  
        int i = low;// 左指针  
        int j = mid   1;// 右指针  
        int k = 0;  

        // 把较小的数先移到新数组中  
        while (i <= mid && j <= high) {  
            if (nums[i] < nums[j]) {  
                temp[k  ] = nums[i  ];  
            } else {  
                temp[k  ] = nums[j  ];  
            }  
        }  

        // 把左边剩余的数移入数组  
        while (i <= mid) {  
            temp[k  ] = nums[i  ];  
        }  

        // 把右边边剩余的数移入数组  
        while (j <= high) {  
            temp[k  ] = nums[j  ];  
        }  

        // 把新数组中的数覆盖nums数组  
        for (int k2 = 0; k2 < temp.length; k2  ) {  
            nums[k2   low] = temp[k2];  
        }  
    }


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int []a = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        MergeSort.sort(a, 0, a.length-1);

        for (int i = 0 ; i< a.length ; i  )
            System.out.print(a[i] " ");

    }

       2). 飞速排序 不地西泮
        1. 取数组中间索引(pivotIndex)
        2. 去数组中间地点元素(pivot = Number(array.splice(pivotIndex, 1)))
        3. 新建多个空数组left, right
        4. 循环跟数组中间成分比较,大的放right,小的放left
        5. 递归回调: 对left,right 分别递归回调变成平稳的数组后
        6. 最后,将长久以来的left pivot right 三有个别 concat 起来

排序:
  1. 里面排序:
    (1). 交流排序:
      1). 冒泡排序 稳固
        三次相比较相邻多个因素的抑扬顿挫,顺序错误的,将其岗位交流
        (从高位到低位 大概 从未有到高位卡塔 尔(英语:State of Qatar)

 1 var array = [6, 5, 3, 1, 8, 7, 2, 4],
 2     temp = '',
 3     i = array.length - 1;
 4     while (i > 0) {
 5         let pos = 0;
 6         for (let j = 0; j < i; j  ) {
 7             if (array[j] > array[j   1]) {
 8                 pos = j;
 9                 let temp = array[j];
10                 array[j] = array[j   1];
11                 array[j   1] = temp;
12             }
13         }
14         i = pos;
15     }
16     console.log(array)

 1         var arr=[49,38,65,97,76,13,27,49,55,4],
 2         len=arr.length;
 3         for(var fraction = Math.floor(len/2);fraction>0;fraction = Math.floor(fraction/2)){
 4             for(var i=fraction;i<len;i  ){
 5                 for(var j=i-fraction;j>=0&&arr[j]>arr[fraction j];j-=fraction){
 6                     var temp=arr[j];
 7                     arr[j]=arr[fraction j];
 8                     arr[fraction j]=temp;
 9                 }
10             }
11         }
12         console.log(arr);

初始版: 

      2). 基数排序: 牢固
  2. 外界排序:
    (1). 计数排序 稳固
    (2). 桶排序 稳定

 

分分快三计划 1

      2). 堆排序 不稳定

 1         var array = [6,5,3,1,8,7,2,4],
 2               length = array.length;
 3         for (let i = 0; i < length - 1; i  ) {
 4             let minIndex = i;
 5             console.log(array[minIndex]);
 6             for (let j = i   1; j < length; j  ) {
 7                 if (array[j] < array[minIndex]) {
 8                     minIndex = j;
 9                 }
10             }
11             let temp = array[i];
12             array[i] = array[minIndex];
13             array[minIndex] = temp;
14             console.log(array);
15         }
16         console.log(array)

    (4). 归拢列排在一条线序: 牢固
      1). 递归原理
        1. 应用递归将数组对半开分为 left,right 多少个数组,直到各个拆分完的数组中唯有多少个因素截止,将各种数组视为有序数组
        2. 创立八个新的数组 newArray 来放排好序的成分
        3. 从种种数组的第2个因素开端拿来相比,往newArray里放,小的先放,大的后放
        注:步骤1 是递归进最里层,步骤3 是递归往外出,最终获得稳步种类

      3). Hill排序 不安定
        不太明了

 

      2). 二分法插入排序
        1. 取冬辰系列第一个因素作为一直以来连串(即有序种类的苗头)(有序种类:array[0]~array[i-1])
        2. 取下叁个成分(array[i])作为被插入元素并做记录为 key
        3. 取有序系列的最初及利落地点的目录分别为 left 和 right
        4. 取有序体系的高中级索引为 middle= Math.floor((left right)/2)
        5. 将 middle 地方的因素 array[middle] 与 被插入成分key 比较,
          如果 key > array[middle],便置 left = middle 1,
          反之 key > array[middle] ,则置 right = middle-1,
          直至 right < left 为止
          (此步骤为 二分查找 原理)
        6. 对从 left 到 key值成分所在地方索引 i-1 处之间的不改变体系 array[left]~array[i-1] 与 key 两个之间利用 直接插入法 举办插队
        7. 重复以上步骤 2~6

 

    (3). 选取排序:
      1). 轻易选拔排序 不安宁
        1. 取系列的第二个元素作为长期以来体系,并取该种类末尾索引地点为作参考,minIndex=0
        2. 从系列的第三个因素开头与 array[minIndex] 做比较,假诺小就记该因素地点索引为 minIndex,
        3. 重复操作步骤2 直到再无更加小成分结束,将那时的 minIndex 与平稳体系的末梢成分交流
        (先从未排序系列中寻觅最小(大卡塔 尔(阿拉伯语:قطر‎成分,将该最小成分与类别的发轫地方沟通,至此 最小成分即到了一直以来成分的苗头地方,
        然后 再从剩余的未排序类别中一连搜寻最小(大卡塔尔成分,依次与未排序体系中的最初地方沟通,至此次大的成分就相继停放了一直以来类别的末尾)

 1         var array = [6,5,3,1,8,7,2,4];
 2         for (let i = 1; i < array.length; i  ) {
 3             let key = array[i];
 4             let j = i - 1;
 5             while (j >= 0 && array[j] > key) {
 6                 array[j   1] = array[j];
 7                 j--;
 8             }
 9             array[j   1] = key;
10         }
11         console.log(array)
 1         var array = [6,5,3,1,8,7,2,4],
 2         length = array.length,
 3         temp = '',
 4         left = 0,
 5         right = length-1;
 6         while (left<right) {
 7             for (var i=0; i<right; i  ) {
 8                 if (array[i]>array[i 1]) {
 9                     temp = array[i];
10                     array[i] = array[i 1];
11                     array[i 1] = temp;
12                 }
13             }
14             right--;
15             for (var i=right; i>left; i--) {
16                 if (array[i]<array[i-1]) {
17                     temp = array[i];
18                     array[i] = array[i-1];
19                     array[i-1] = temp;
20                 }
21             }
22             left  ;
23         }
24         console.log(array)
 1           var array = [6, 5, 3, 1, 8, 7, 2, 4],
 2         length = array.length,
 3         temp = '';
 4         for (var i=0; i<length-1; i  ) {
 5             for (var j=0; j<length-i-1; j  ) {
 6                 if (array[j]>array[j 1]) {
 7                     temp = array[j];
 8                     array[j] = array[j 1];
 9                     array[j 1] = temp;
10                 }
11             }
12         }
13         console.log(array)    
 1         var array = [6,5,3,1,8,7,2,4];
 2         for (let i = 1; i < array.length; i  ) {
 3             let key = array[i], left = 0, right = i - 1;
 4             //console.log(i '  ' key);
 5             //console.log(left '==' right);
 6             while (left <= right) {
 7                 let middle = parseInt((left   right) / 2);
 8                 //console.log(left '==' middle '==' right)
 9                 if (key < array[middle]) {
10                     right = middle - 1;
11                 } else {
12                     left = middle   1;
13                 }
14                 //console.log(left '==' right)
15             }
16             //console.log(array)
17             for (let j = i - 1; j >= left; j--) {
18                 array[j   1] = array[j];
19             //console.log(array)
20             }
21             array[left] = key;
22             //console.log(array)
23         }
24         console.log(array)
 1 var array = [6,5,3,1,8,7,2,4];
 2 function quickSort(array) {
 3     if (array.length <= 1) {
 4         return array;
 5     }
 6     const pivotIndex = parseInt(array.length / 2);
 7     const pivot = Number(array.splice(pivotIndex, 1));
 8     const left = [];    const right = [];
 9     for (let i = 0; i < array.length; i  ) {
10         if (array[i] < pivot) {
11             left.push(array[i]);
12         } else {
13             right.push(array[i]);
14         }
15     }
16     return quickSort(left).concat([pivot], quickSort(right));
17 };
18 console.log(array)            

本文由分分快三计划发布,转载请注明来源

关键词: 分分快三计划 JavaScript 计算机基础