3

1.排序*

快速排序选择排序希尔排序冒泡排序

排序算法的时间复杂度和空间复杂度

快速排序:

  • 1.在未排序序列中找到最小(大)元素,存放到排序序列的起始位置
  • 2.从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。
  • 3.重复第二步,直到所有元素均排序完毕。
//快速排序

var quickSort = function(arr) {
    if (arr.length <= 1) { return arr; }
    var pivotIndex = Math.floor(arr.length / 2);   //基准位置(理论上可任意选取)
    var pivot = arr.splice(pivotIndex, 1)[0];  //基准数
    var left = [];
    var right = [];
    for (var i = 0; i < arr.length; i++){
        if (arr[i] < pivot) {
            left.push(arr[i]);
        } else {
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat([pivot], quickSort(right));  //链接左数组、基准数构成的数组、右数组
};

选择排序:

  • 1.在未排序序列中找到最小(大)元素,存放到排序序列的起始位置
  • 2.从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。
  • 3.重复第二步,直到所有元素均排序完毕。
//选择排序

function selectionSort(arr) {
    var len = arr.length;
    var minIndex, temp;
    for (var i = 0; i < len - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {     // 寻找最小的数
                minIndex = j;                 // 将最小数的索引保存
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
}

希尔排序:

  • 1.选择一个增量序列 t1,t2,……,tk,其中 ti > tj, tk = 1;
  • 2.按增量序列个数 k,对序列进行 k 趟排序;
  • 3.每趟排序,根据对应的增量 ti,将待排序列分割成若干长度为 m 的子序列,分别对各子表进行直接插入排序。仅增量因子为 1 时,整个序列作为一个表来处理,表长度即为整个序列的长度。
//希尔排序

function shellSort(arr) {
    var len = arr.length,
        temp,
        gap = 1;
    while(gap < len/3) {          //动态定义间隔序列
        gap = gap*3+1;
    }
    for (gap; gap > 0; gap = Math.floor(gap/3)) {
        for (var i = gap; i < len; i++) {
            temp = arr[i];
            for (var j = i-gap; j >= 0 && arr[j] > temp; j -= gap) {
                arr[j+gap] = arr[j];
            }
            arr[j+gap] = temp;
        }
    }
    return arr;
}

冒泡排序:

  • 1.从序列头部开始遍历,两两比较,如果前者比后者大,则交换位置;
  • 2.下次遍历时,此前每次遍历后的最大数不再参与排序;
  • 3.多次重复此操作,直到序列排序完成。
//冒泡排序

function bubbleSort(arr){
    var temp,swap;
    for(i=0;i<arr.length-1;i++){
        swap=false;
        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;
                
                swap=true;
            }
        }
        if(!swap){
            break;
        }
    }
    return arr;
}

2.其他

2.1堆栈*、队列、链表
数组:pop()/push()/shift()/unshift(),本身具有堆栈和队列的特点。
堆栈队列链表
2.2递归*(60%)
递归
2.3波兰式和逆波兰式
理论源码


stefanieliang
190 声望19 粉丝

一天一笔记~