排序

冒泡排序

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

选择排序

function selectSort(arr) {
    let index = 0;
    for(let i = 0; i < arr.length -1; i++) {
        index = i;
        for(let j = i+1; j < arr.length; j++) {
            if(arr[index] > arr[j]){ // 寻找最小值
                index = j; // 保存最小值的索引
            }
        }
        if(index != i) {
            let temp = arr[index];
            arr[index] = arr[i];
            arr[i] = temp;
        }
    }
    return arr;
}

快速排序

function quickSort(arr) {
    let temp = Math.floor(arr.length/2);
    let middle = arr.splice(temp,1); // 中间值
    let left = [];
    let right = [];
    for(let i = 0; i < arr.length-1; i++){
        if(arr[i] < temp) {
            left.push(arr[i]);
        } else {
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat(temp,quickSort(right));
}

插入排序

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

归并排序

function mergeSort(arr) {
    let len = arr.length;
    if(len > 1) {
        let index = Math.floor(len/2);
        let left = arr.slice(0, index);
        let right = arr.slice(index);
        merge(mergeSort(left), mergeSort(right))
    } else {
        return arr;
    }
}
function merge(left, right) {
    let arr = [];
    while(left.length && right.length) {
         if(left[0] < right[0]){
            arr.push(left.shift());
        } else {
            arr.push(right.shift());
        }
    }
    return arr.concat(left, right);
}

二分查找

function binarySort(arr, target){
    let left = 0;
    let right = arr.length - 1;
    while(left < right){
        let middle = left + (right -left)/2;
        if(arr[middle] = target) {
            return middle;
        } else if(arr[middle] < target){
            left = middle + 1;
        } else if (arr[middle] > target) {
            right = middle - 1;
        } else {
            return -1;
        }
    }
}

希尔排序

function shellSort(list) {
  var gap = Math.floor(list.length/2);
  while (gap > 0) {
    for (i = gap; i < list.length; i++) {
      temp = list[i];
      for(j = i;j >= gap && list[j - gap] > temp;j -= gap){
        list[j] = list[j - gap];
       }
       list[j] = temp;
     }
     gap = Math.floor( gap / 2 );
   }
   return list;
}
var theArray = [2,1,3,12,5,66,23,87,15,32];
console.log(shellSort(theArray));

反转链表

zhuanlan.zhihu.com/p/440518958

var reverseList = function (head) {
  let temp = new ListNode();
  let next = null;
  while (head) {
    next = head.next;//下一个节点
    head.next = temp.next;
    temp.next = head;//head接在temp的后面
    head = next;//head向后移动一位
  }
  return temp.next;
};

反转链表II

var reverseBetween = function(head, left, right) {
    const dummyNode = new ListNode(-1);
    dummyNode.next = head;//虚拟头节点

    let pre = dummyNode;
    for (let i = 0; i < left - 1; i++) {//pre遍历到left的前一个节点
        pre = pre.next;
    }

    let rightNode = pre;
    for (let i = 0; i < right - left + 1; i++) {//rightNode遍历到right的位置
        rightNode = rightNode.next;
    }

    let leftNode = pre.next;//保存leftNode
    let curr = rightNode.next;//保存rightNode.next

    //切断left到right的子链
    pre.next = null;
    rightNode.next = null;

        //206题的逻辑 反转left到right的子链
    reverseLinkedList(leftNode);

    //返乡连接
    pre.next = rightNode;
    leftNode.next = curr;
    return dummyNode.next;
};

const reverseLinkedList = (head) => {
    let pre = null;
    let cur = head;

    while (cur) {
        const next = cur.next;
        cur.next = pre;
        pre = cur;
        cur = next;
    }
}

两两交换链表中的节点

var swapPairs = function(head) {
    if (head === null|| head.next === null) {//终止条件，必须要有两个节点
        return head;
    }
    const newHead = head.next;//反转后链表的头节点，
    head.next = swapPairs(newHead.next);//让当前递归层的head.next指向交换后返回的头节点
    newHead.next = head;//让反转后的新的头节点指向当前层的head的节点
    return newHead;//返回反转后的头节点
};

删除链表中的节点

var deleteNode = function(node) {
    node.val = node.next.val//将要删除节点的下一个节点的值覆盖自己的值Ï
    node.next = node.next.next//让当前节点指向下一个节点的next
};

删除链表的倒数第N个节点

var removeNthFromEnd = function (head, n) {
    let dummy = new ListNode();
    dummy.next = head;
    let n1 = dummy;
    let n2 = dummy;
    for (let i = 0; i <= n; i++) {//n2移动n+1次
        n2 = n2.next;
    }
    while (n2 !== null) {//同时移动n1，n2
        n1 = n1.next;
        n2 = n2.next;
    }
    n1.next = n1.next.next;//删除元素
    return dummy.next;
};

移除链表元素

//例：0->1->2->3  val=2
//level1: 0.next = removeElements(1, 2);            return 1                    0->1->3->null
//level2: 1.next = removeElements(2, 2);            return 3                    1->3->null
//level3: 2.next = removeElements(3, 2);            return 3                    2->3->null
//level4: 3.next = removeElements(null, 2);     return null;        3->null

var removeElements = function(head, val) {
    if (head === null) {//递归终止 遍历完了链表
      return head;
    }
    head.next = removeElements(head.next, val);//递归调用函数removeElements
    return head.val === val ? head.next : head;//如果当前元素值是val，则返回下一个元素，否则直接返回当前元素
};

合并两个有序链表

var mergeTwoLists = function(l1, l2) {
  //递归终止 分隔到不能分割 也就是两个链表有一个的nxet不存在了 那就没法分割问题了 只能返回
    if (l1 === null) {
        return l2;
    } else if (l2 === null) {
        return l1;
    } else if (l1.val < l2.val) {//当前节点谁小，就让这个较小的节点的next和另一个链表继续递归合并
        l1.next = mergeTwoLists(l1.next, l2);//分隔成合并l1.next, l2的子问题
        return l1;
    } else {
        l2.next = mergeTwoLists(l1, l2.next);
        return l2;
    }
};

删除排序链表中的重复元素

var deleteDuplicates = function(head) {
    let cur = head;
    while(cur && cur.next) {
        if(cur.val == cur.next.val) {
            cur.next = cur.next.next;
        } else {
            cur = cur.next;
        }
    }
    return head;
};