栈

eg. 弹栈压栈的过程

后进先出

链表

就是原型链不断的连接，要断去某个链，就让x的前一个等于x的后一个，这样就不走x从而断开
链表的怎删改查
eg.

let createNode = value => {
  return {
    data: value,
    next: null
  };
};
let removeFromlist = (list, node) => {
  let p = null;
  let x = list;
  while (x !== node) {
    p = x;
    x = x.next;
  }
  p.next =
    x.next; /*p代表的是上一个节点的x，所以根据我们删节点得到的规律就是让list的上一个节点等于list的下一个节点，这样list没用就被删了
p.next===x,也就是x和x.next相同，这样到达x.next.next的时候只要经过x而不用经过x---x.next---x.next.next，所以x.next就被删掉了*/
};
//删
let createList = value => {
  return createNode(value);
};
//增
let appendlist = (list, value) => {
  let node = createNode(value);
  let x = list;
  while (x.next) {
    x = x.next;
  }
  //x.next === null; //x是最后一项
  x.next = node;
  return node;
};

let travelList = (list, fn) => {
  let x = list;
  while (x !== null) {
    fn(x);
    x = x.next;
  }
}; //查
let list = createList(10);
let node2 = appendlist(list, 20);
let node3 = appendlist(list, 30);
console.log("list");
console.log(list);
travelList(list, node => {
  console.log(node.data);
});

变形

双向：除去next，data外还有一个previous属性指向上一个
循环：最后一个不是null而是指向第一项

tree

链表的升级，一个可以对应多个
eg.

let createTree = value => {
  return { data: value, children: null, parent: null };
};

//增
let addChild = (node, value) => {
  let Newnode = {
    data: value,
    children: null,
    parent: node
  };
  node.children = node.children || [];
  node.children.push(Newnode);
  return Newnode;
};
//查
let travel = (tree, fn) => {
  fn(tree); //先看根节点
  if (!tree.children) {
    return;
  }
  for (let i = 0; i < tree.children.length; i++) {
    travel(tree.children[i], fn);
  } //再看子节点的每棵树
};
let fn = node => {
  console.log(node.data);
};
//删(哪个对应节点包含了某个数，要找他的爸爸,所以要先弄一个find的函数)
let find = (tree, node) => {
  if (tree === node) {
    //如果树就是要找的，就return树
    return tree;
  } else if (tree.children) {
    //没就去他儿子里面找
    for (let i = 0; i < tree.children.length; i++) {
      let result = find(tree.children[i], node);
      if (result) {
        return result;
      }
    }
    return undefined; //result不存在回undefinded
  } else {
    return undefined;
  } //}tree.result不存在回undefined
};

//开始删了
let removeNode = (tree, node) => {
  let siblings = node.parent.children; //他的兄弟姐妹
  let index = 0;
  for (let i = 1; i < siblings.length; i++) {
    if (siblings[i] === node) {
      index = i;
    }
    siblings.splice(index, 1);
  }
};

let tree = createTree(10);
let node2 = addChild(tree, 40);
addChild(tree, 20);
addChild(tree, 30);
addChild(node2, 50);
addChild(node2, 60);
removeNode(tree, node2);
console.log(tree);

哈希

看这个
个人简单的理解：
很简单，我们把你的车牌号看作一个8位36进制的数字；为了方便，我们可以把它转换成十进制。那么，你的车牌号就是一个不大于2821109907456的数字。现在，我们把你的车牌号除以一万，只取余数——你看，你的车牌号是不是就和0_{10000之间的数字对应起来了？很好，你的车就停在这个数字对应的停车位上，过去开就是了——O(1)的查找效率！这个“把你的车牌号映射进0}10000之间”的操作，就是所谓的“散列”“杂凑”“哈希”或者hash（当然，实践上，为了尽量减少冲突，哈希表的空间大小会尽量取质数）。相对于“以key为下标直接访问的数组”，哈希表是“时间换空间”；相对于二分法查找，哈希表又是“以空间换时间”。这种“中庸”的定位使得它在许多场合极为好用。

如果冲突就叠起来或者顺延一位，但还是看这个文章比较好