去面试吧之算法与数据结构

数据结构:

列表

 

栈

栈是一种后入先出的数据结构，其实是一种特殊的列表，栈内的元素只能通过

 

队列

队列也是一种特殊的列表，和栈不同的是，队列是一种先进先出的数据结构，

 

二叉树树

二叉查找树是一种特殊的二叉树，相对较小的值保存在做节点，较大的值保存在右节点。

查找正确插入点的算法：
  // 1：设根节点为当前节点；
  // 2：如果待插入节点保存的数据小于当前节点，则设新的当前节点为原节点的左节点，反之，执行第四步。
  // 3：如果当前节点的左节点为null，就将新节点插入这个位置，退出循环；反之，继续执行下一次循环；
  // 4：设新的当前节点为原节点的右节点；
  // 5：如果当前节点的右节点为null，就将新的节点插入这个位置，退出循环；反之，继续执行下一次循环。

　　

先序遍历：先访问根节点，然后以同样的方式访问左子树和右子树

function preOrder (node) {
   if(!(node == null)) {
     console.log(node.show());
     preOrder(node.left);
     preOrder(node.right);
   }
 };

　　

中序遍历：先访问左子树，再访问根节点，最后访问右子树

 function inOrder (node) {
   if(!(node == null)) {
     inOrder(node.left);
     console.log(node.show());
     inOrder(node.right);
   }
 };

　　

后序遍历：先访问叶子节点，从左子树到右子树，再到根节点

function postOrder(node) {
  if(!(node == null)) {
    postOrder(node.left);
    postOrder(node.right);
    console.log(node.show());
  }
};

　　

链表

单向链表，每一个节点指向下一个节点的链接，最后一个节点指向null

双向链表，每一个节点不仅保存指向下一个节点的链接还保存着指向前一个节点的链接

 

算法：

冒泡

let bubbleSortFlag = function(arr) {
    const times = arr.length;
    let temp;
    let flag = true;
    for (let i = 0; i < times; i++) {
        for (let j = 0; j < times - 1 - i; j++) {
            flag = false;
            if (arr[j] > arr[j + 1]) {
                temp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
                flag = true;
            }
        }
        if (!flag) {
            break;
        }
    }
    return arr;
}

　　

快速

let quickSort = function(arr) {
    if (arr.length < 1) {
        return arr; }　　
    let pivotIndex = Math.floor(arr.length / 2);
    let pivot = arr.splice(pivotIndex, 1)[0];　　
    let left = [];　　
    let right = [];　　
    for (let 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));
};  

　　

选择

let selectionSort = function(arr){
    let len = arr.length;
    let minIndex, temp;
    for (let i = 0; i < len - 1; i++) {
        minIndex = i;
        for (let 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;
};