计算机基础：数据结构八大类数据结构有：数组（Array）、栈（Stack）、队列（Queue）、链表（Linked Li

数据结构概述

数据结构是计算机存储、组织数据的方式；

通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构的优良将直接影响着我们程序的性能；常用的数据结构有：数组（Array）、栈（Stack）、队列（Queue）、链表（Linked List）、树（Tree）、图（Graph）、堆（Heap）、散列表（Hash）等；

数据结构的分类

1.2.1 排列方式

1）集合

集合：数据结构中的元素之间除了“同属一个集合” 的相互关系外，别无其他关系；

2）线性结构

线性结构：数据结构中的元素存在一对一的相互关系；

3）树形结构

树形结构：数据结构中的元素存在一对多的相互关系；

4）图形结构

图形结构：数据结构中的元素存在多对多的相互关系；

1.2.2 逻辑结构

数据结构按逻辑上划分为线性结构与非线性结构；

线性结构：有且仅有一个开始结点和一个终端结点，并且所有结点都最多只有一个直接前驱和一个直接后继。典型的线性表有：链表、栈和队列。它们共同的特点就是数据之间的线性关系，除了头结点和尾结点之外，每个结点都有唯一的前驱和唯一的后继，也就是所谓的一对一的关系。

非线性结构：对应于线性结构，非线性结构也就是每个结点可以有不止一个直接前驱和直接后继。常见的非线性结构包括：树、图等。

数据结构的实现

数组

数组（Array）：数组是有序元素的序列，在内存中的分配是连续的，数组会为存储的元素都分配一个下标（索引），此下标是一个自增连续的，访问数组中的元素通过下标进行访问；数组下标从0开始访问；

数组的优点：查询速度快；

数组的缺点：删除增加、删除慢；由于数组为每个元素都分配了索引且索引是自增连续的，因此一但删除或者新增了某个元素时需要调整后面的所有元素的索引；新增一个元素40到3索引下标位置：

删除2索引元素：

总结：数组查询快，增删慢，适用于频繁查询，增删较少的情况；

链表

链表（Linked List）：链表是由一系列节点Node（也可称元素）组成，数据元素的逻辑顺序是通过链表的指针地址实现，通常情况下，每个节点包含两个部分，一个用于存储元素的内存地址，名叫数据域，另一个则指向下一个相邻节点地址的指针，名叫指针域；

根据链表的指向不同可分为单向链表、双向链表、循环链表等；我们本章介绍的是单向链表，也是所有链表中最常见、最简单的链表；

链表的节点（Node）：

完整的链表：

链表的优点： 新增节点、删除节点快；在链表中新增一个元素：

在单向链表中，新增一个元素最多只会影响上一个节点，比在数组中的新增效率要高的多；

在链表中删除一个元素：

链表的缺点：

1）查询速度慢，查询从头部开始一直查询到尾部，如果元素刚好是在最尾部那么查询效率势必非常低；

2）链表像对于数组多了一个指针域的开销，内存相对占用会比较大；

总结：数据量较小，需要频繁增加，删除操作的场景，查询操作相对较少；


class Node {
  constructor(val) {
    this.val = val;
    this.next = null;
  }
}

//创建链表类
class LinkNodeList {
  constructor() {
    this.head = null;
    this.count = 0;
  }
}

head表示头节点，count表示链表节点个数。我们需要实现哪些方法呢？

push(element)：向链表尾部添加一个新元素。
insert(element, position)：向链表的特定位置插入一个新元素。
getVal(index)：返回链表中特定位置的元素。如果链表中不存在这样的元素，则返回undefined。
remove(position)：从链表的特定位置移除一个元素。
isEmpty()：如果链表中不包含任何元素，返回true，如果链表长度大于0则返回false。
size()：返回链表包含的元素个数，与数组的length属性类似。
toString()：返回表示整个链表的字符串。

class linkList {
  constructor() {
    this.head = null; //头指针，指向第一个链表节点
    this.length = 0; //链表的长度
  }

  //创建链表节点的方法
  createNode(data) {
    return {
      data,
      next: null
    }
  }

  toString() {
    // 1.定义两个变量
    let current = this.head
    let res = ""

    // 2.循环获取链表中所有的元素
    while (current) {
        res += "," + current.data
        current = current.next
    }

    // 3.返回最终结果
    return res.slice(1)
  }

  append(data) {
    //1. 创建新节点
    const node = this.createNode(data);

    //2. 判断是否是空链表
    if (this.head === null) {
      // 如果是空链表，新节点直接作为头节点
      this.head = node;
    } else {
      // 如果不是空链表，先拿到头指针
      let current = this.head;
      // 从头遍历直到末尾的节点
      while (current.next) {
        current = current.next;
      }

      //找到了末尾节点，插入新节点
      current.next = node;
    }

    //3. 链表长度 + 1
    this.length++;
  }

  insert(position, data) {
    // 1. 越界判断
    if (position < 0 || position > this.length) return false

    // 2.找到正确的位置, 并插入数据
    const newNode = this.createNode(data);
    let current = this.head
    let previous = null
    let index = 0

    // 3.判断是否列表是否在第一个位置插入
    if (position == 0) {
        newNode.next = current
        this.head = newNode
    } else {
        while (index++ < position) {
            // 记录当前节点
            previous = current
            // 再遍历下一个节点
            current = current.next
        }
        
        // 插入节点
        newNode.next = current
        previous.next = newNode
    }
    
    this.length++
    
    return true
  }

  remove(data) {
    // 1. current 从头节点开始，previous 记录上一个节点
    let current = this.head
    let previous = null

    // 2. 如果是删除头节点
    if (current.data === data) {
      this.head = current.next
      current.next = null
      this.length--
      return
    }
    
    // 3. 查找要删除的那个节点
    while (current !== null && current.data !== data) {
      previous = current
      current = current.next
    }

    // 4. 如果没找到要删除的节点
    if (current === null) {
      throw new Error("dont find the node to delete")
    }
    
    // 5. 找到了，删除节点
    previous.next = current.next ?? null;
    current.next = null

    // 6. 长度减一
    this.length--
  }

  indexOf(data) {
    let current = this.head
    let index = 0
    
    // 遍历链表
    while (current) {
        if (current.data === data) {
            return index
        }

        index++
        current = current.next
    }
    
    // 3. 来到这个位置, 说明没有找到, 则返回-1
    return -1
  }

  removeAt(position) {
    // 1. 越界判断
    if (position < 0 || position >= this.length) return null

    let current = this.head
    let previous = null
    let index = 0
    
    // 2. 判断是否是移除第一项
    if (position === 0) {
        this.head = current.next
    } else {
        while (index++ < position) {
            previous = current
            current = current.next
        }
        
        previous.next = current.next
    }
    
    // 4.length-1
    this.length--
    
    // 5.返回移除的数据
    return current.data
  }

  isEmpty() {
    return this.length === 0
  }

  size() {
    return this.length
  }
}

栈

栈（Stack）：是一种特殊的线性表，仅能在线性表的一端操作，栈顶允许操作，栈底不允许操作。栈的特点是：先进后出从栈顶放入元素的操作叫入栈（压栈），取出元素叫出栈（弹栈）。

栈的特点：先进后出，Java中的栈内存就是一个栈的数据结构，先调用的方法要等到后调用的方法结束才会弹栈（出栈）；

入栈操作：

出栈操作：

队列

队列（Queue）：队列与栈一样，也是一种线性表，其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。队列的特点是先进先出，从一端放入元素的操作称为入队，取出元素为出队；

队列的特点：先进先出；

树

树是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。把它叫做 “树” 是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：

1）每个节点有0个或多个子节点；

2）没有父节点的节点称为根节点；

3）每一个非根节点有且只有一个父节点；

4）除了根节点外，每个子节点可以分为多个不相交的子树；

5）右子树永远比左子树大，读取顺序从左到右；

树的分类有非常多种，平衡二叉树（AVL）、红黑树RBL（R-B Tree）、B树（B-Tree）、B+树（B+Tree）等，但最早都是由二叉树演变过去的；

二叉树的特点：每个结点最多有两颗子树

堆

堆（Heap）：堆可以看做是一颗用数组实现的二叉树，所以它没有使用父指针或者子指针。堆根据“堆属性”来排序，“堆属性”决定了树中节点的位置。

堆的特性：如果一个结点的位置为k，则它的父结点的位置为[k/2]，而它的两个子结点的位置则分别为2k和2k+1。这样，在不使用指针的情况下，我们也可以通过计算数组的索引在树中上下移动：从arr[k]向上一层，就令k等于k/2,向下一层就令k等于2k或2k+1。

堆的定义如下：n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时，称之为堆；

(ki <= k2i,ki <= k2i+1)或者(ki >= k2i,ki >= k2i+1)满足前者的表达式的成为小顶堆（小根堆），满足后者表达式的为大顶堆（大根堆），很明显我们上面画的堆数据结构是一个大根堆；

大小根堆数据结构图：

一般来说将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。

散列表

散列表（Hash），也叫哈希表，是根据键和值 (key和value) 直接进行访问的数据结构，通过key和value来映射到集合中的一个位置，这样就可以很快找到集合中的对应元素。它利用数组支持按照下标访问的特性，所以散列表其实是数组的一种扩展，由数组演化而来。散列表首先需要根据key来计算数据存储的位置，也就是数组索引的下标；

HashValue=hash(key) 散列表就是把Key通过一个固定的算法函数既所谓的哈希函数转换成一个整型数字，然后就将该数字对数组长度进行取余，取余结果就当作数组的下标，将value存储在以该数字为下标的数组空间里，这种存储空间可以充分利用数组的查找优势来查找元素，所以查找的速度很快。