数据结构：栈、队列、链表

队列

队列是一种特殊的线性结构。他只允许在队列的首部进行删除操作，这成为出队。而在队列的尾部进行插入操作，称为：入队。当队列中没有元素时（head===tail）这样称为空队列。
head=>口口口口口口口口口口<=tail
队列就是先进先出，从tail口放入，如果要删除数据，就从head口删除。
程序案例：一组数组，将该数组中的第一个数字出队，第二个数字放在原数组中的末尾，直到该数组为空数组。

const arr = [0, 6, 3, 1, 7, 5, 8, 9, 2, 4]
const arrNum = []
head = 0
tail = arr.length
while (head < tail) {
  arrNum.push(arr[head])
  head += 1
  arr[tail] = arr[head]
  tail += 1
  head += 1
}
console.log(arrNum)

[ 0, 3, 7, 8, 2, 6, 5, 4, 9, 1 ]
```
```
//之后有看到《数据结构与算法JavaScript描述》对于队列有其他的写法。你会发现自己定义构造函数以后，会清晰很多，并且一劳永逸
function Queue() {
  this.dataSource = []
  this.enqueue = enqueue
  this.dequeue = dequeue
  this.front = front
  this.back = back
  this.toString = toString
  this.empty = empty
}
function enqueue(element) {
  this.dataSource.push(element)
}
function dequeue() {//删除队首
  return this.dataSource.shift()
}
function front() {//队首
  return this.dataSource[0]
}
function back() {
  return this.dataSource[this.dataSource.length-1]
}
function toString() {
  var resStr=''
  for (let i=0;i<this.dataSource.length;++i){
    resStr+=this.dataSource[i]+'\n'
  }
  return resStr
}
function empty() {
  if (this.dataSource.length===0){
    return true
  }else {
    return false
  }
}
var q=new Queue()
q.enqueue('1')
q.enqueue('2')
q.enqueue('3')
console.log(q.toString())//1 2 3
q.dequeue()
console.log(q.toString())// 2 3
console.log('队首元素',q.front())// 队首元素 2

console.log('队尾元素',q.back())// 队尾元素 3

```
####栈
先进后出的数据结构：数据从栈顶进去，从栈顶出来。
栈顶
口
口
口
口
栈底
程序案例：回文（没看数据结构之前，会想着什么正则一下，然后过滤。知道了用栈去处理回文～逼格高了好多呢）

```
原理：回文不就是判断正着读和倒着读是否一样吗？
例如xyzyx，取中间字符z，只要将z之前的字符串放入栈中，然后由栈的读取方式取出，
（放入顺序是x，y；取出是y，x）
判断取出的数据是否与z右边的字符一致，不就对了！！
const arr = ['x', 'y', 'z', 'y', 'z']
const mid = parseInt(arr.length / 2)
const right = mid + 1
const leftArr = []
for (let i = 0; i < mid; i += 1) {
  leftArr.push(arr[i])
}
for (let j = right; j < arr.length; j += 1) {
  if (leftArr.pop() !== arr[j]) {
    console.log('不匹配')
  }
}
```
```
//之后有看到《数据结构与算法JavaScript描述》对于栈有其他的写法。
function Stack() {
  this.dataStore = []
  this.top = 0
  this.push = push
  this.peek = peek
  this.pop = pop
  this.clear = clear
  this.length = length
}
function push(element) {
  this.dataStore[this.top++] = element
}
function peek() {
  return this.dataStore[this.top - 1]
}
function pop() {
  return this.dataStore[--this.top]
}
function clear() {
  this.top = 0
  this.dataStore = []
}
function length() {
  return this.top
}


var s=new Stack()
s.push('a')
s.push('b')
s.push('c')
console.log(s.dataStore)// [ 'a', 'b', 'c' ]
console.log(s.length())// 3
console.log(s.peek())// c
var poped=s.pop()
console.log(poped)// c
s.push('last')
console.log(s.dataStore)// [ 'a', 'b', 'last' ]
s.clear()
console.log(s.length())
console.log(s.peek())//undefined
s.push('helolo')
console.log(s.peek())
```
还有个案例，用栈模拟递归，可以借鉴一下
```
function fact(n) {
  var s = new Stack()
  while (n > 1) {
    s.push(n--)
  }
  var product=1
  while (s.length()>0){
    product*=s.pop()
  }
  return product
}
console.log(fact(5))//120
```
####链表
在我看来，简易链表就相当于内存块，内存块中分两部分，第一部分放自己的内容，第二部分放下一个内容的地址。类似于c语言里的指针。
其实这种链表的原理可以用对象去表现出来。先上一段我理解的链表，后期将补充。