排序算法含选择排序

排序算法

插入排序算法

• 简单插入排序
  代码

#include <stdio.h> 
#include <stdlib.h> 
int sort(int arr[],int n); 
int main(){ 
  int n =10; 
  int arr[]={12,24,1,5,3,22,66,10,9,2}; 
  int retuarr; retuarr = sort(arr,10); 
  for (int i=0;i<n;i++){ 
    printf("%d,",arr[i]);
  } 
  system("pause"); return 0; 
} 
int sort(int arr[],int n){ 
  int x=0; int z=0; 
  int current=0; 
  for(int i=1;i<n;i++){
    z=i-1; current =arr[i];
    while (z>=0 && current<arr[z])
    { arr[z+1] = arr[z]; z--; } arr[z+1] = current; 
  } 
  return 1; 
}

简单插入排序通过将数组中的第一个数字作为已排序的数组okArr，从下标1开始，进行遍历数组，arr[i]和okArr数组从后到前的数据进行比较，直到符合交换的条件，结束比较。直到遍历结束

时间复杂度：最好O(n),最坏O(n²),平均O(n²)

• 希尔排序
  代码

function shellsort(a){
    console.log(a)
    var len = a.length;
    while(true){
        len = parseInt(len/2);
        for(var i=0;i<len;i++){ 
            for(var j=i+len;j<a.length;j = j+len){
                var t = a[j]
                var z
                for(z = j-len;z>=0 && a[z]<t;z=z-len){
                    a[z+len] = a[z]
                }
                a[z + len] = t;
            }
        }
        if(len==1){
            break;
        }
    }
    console.log(a)
}
var array =new Array(8,9,12,3,2,11,5,66,7,8)
shellsort(array)

希尔排序属于通过对增量分组进行插入排序，并不断缩小增量，直到分组为1是，排序完成。

每个分组为i+增量的组合，这样排序后才会是整体基本有序，而不是局部有序。

时间复杂度：最坏情况O(N1.5),平均情况O(nLogN),空间复杂度：O(1)

移动排序

- 快速排序

代码

大——》小

function quicksort(a,low,high){
    var i = low;
    var j = high;//哨兵
    var local = a[low];//a.low作为基准数据
    if(low>=high) return  //不要忘记结束条件
    while(i<j){
        while(i<j && a[j]<local){  //因为基准在最左侧，所以先从右侧进行寻找，这很重要
            j--;
        }
        while(i<j && a[i]>=local){
            i++;
        }
        var temp = a[i];
        a[i]= a[j];
        a[j] = temp;
    }
    var temp = a[i];
    a[i] =a[low]
    a[low] = temp; //将基准数据放到i，j重合的位置，相互交换。
    quicksort(a,low,i-1);
    quicksort(a,i+1,high);
}
var array =new Array(8,9,12,3,2,11,5,66,7,8);
quicksort(array,0,array.length-1);
console.log('quicksort is :',array);

快速排序是选择一个基准数字，这里选择第一个数，将大于这个数字的移动到一侧，将小于这个数字的移动到一侧，最后两个哨兵相等的位置就是基准数字的位置，将
基准数字从他的位置与哨兵位置相互交换，

之后从这个位置分别从两侧再次进行快速排序，直到传入的低位大于等于高位。这也是需要哨兵的原因，

时间复杂度：最好：O(nlogN)最坏：O(n ²)平均：O(nlogN)

• 冒泡排序
  代码

function Bubblesort(a) {
    var len  = a.length
    for(var i =0;i<len;i++) {
        for(var j =0;j<len-i;j++) {
            if (a[j] < a[j+1]){
              //每次都是两个相邻的比较
                var temp = a[j]
                a[j] = a[j+1]
                a[j+1] = temp
            }
        }
    }
}

• 选择排序
  代码

  大–>小

 javascript
function Bubblesort(a){
    var len = a.length;
    for(var i=0;i<len;i++){
        for(var j=i+1;j<len;j++){
            if(a[i]<=a[j]){
                var temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
    }
}
var array =new Array(8,9,12,3,2,11,5,66,7,8)
Bubblesort(array)
console.log('bubblesort is :',array);