Js拓展_链表

---

一、链表

1.单向链表

class Node {
  //每个元素有一个data和next
  constructor(element) {
    // 初始化变量和节点
    this.element = element;
    this.next = null;
  }
}

// 单向链表类
class LinkedList {
  constructor() {
    // 链表长度和头指针
    this.size = 0;
    this.head = null;
  }

  //追加元素
  append(element) {
    let node = new Node(element)
    if (this.head === null) {
      this.head = node
    } else {
      let current = this.getNode(this.size - 1)
      current.next = node
    }
    this.size++
  }

  //插入链表 下标 插入值
  appendAt(position, element) {
    // 边距判断
    if (position < 0 || position > this.size) {
      throw  new Error("Position out range")
    }

    let node = new Node(element)
    // 在头部追加
    if (position === 0) {
      node.next = this.head
      this.head = node
    }else{
      // 在中间追加
      // 获取当前节点的前一个节点
      let pre = this.getNode(position -1)
      node.next = pre.next
      pre.next = node
    }
    this.size++
  }

  //删除当前节点
  remove(position) {
    if (position < 0 || position >= this.size) {
      throw  new Error("Position out range")
    }
    let current = this.head
    if (position === 0){
      this.head = current.next
    }else{
      let pre = this.getNode(position-1);
        current = pre.next
        pre.next = current.next
      }
    this.size--
  }

  //查找指定元素的索引
  indexOf(element) {
    let current = this.head
    for (let i = 0; i < this.size; i++) {
      if (current.element === element){
        return i
      }
      current = current.next;
    }
    return -1
  }

  //根据索引获取下一个元素
  getNode(index) {
    if (index < 0 || index >= this.size) {
      throw  new Error("out range")
    }
    let current = this.head
    for (let i = 0; i < index; i++) {
      current = current.next;
    }
    return current
  }
}

let l1 = new LinkedList()
l1.append(1)
l1.append(2)
l1.append(3)
l1.append(4)
l1.append(5)
l1.append(6)
console.dir(l1,{
  depth:100
})

2.双向链表

3.单向循环链表

//单向循环链表其实和单向链表类似，只是比单向链表多了一个属性，让其在尾部对链表进行追加，使其的指针指向链表的第一个元素
class Node {
  //每个元素有一个data和next
  constructor(element) {
    // 初始化变量和节点
    this.element = element;
    this.next = null;
  }
}

// 单向链表类
class LinkedList {
  constructor() {
    // 链表长度和头指针
    this.size = 0;
    this.head = null;
    this.tail = null;
  }

  //追加元素
  append(element) {
    let node = new Node(element)
    // 若当前节点找不到上一个节点，则让当前头为node
    if (this.head === null) {
      this.head = node
    } else {
      // 若当前节点有上一个节点，则让上一个节点指向当前节点
      let current = this.getNode(this.size - 1)
      current.next = node
    }
    this.tail = node
    this.size++
  }

  //插入链表 下标 插入值
  appendAt(position, element) {
    // 边距判断
    if (position < 0 || position > this.size) {
      throw  new Error("Position out range")
    }
    let node = new Node(element)
    // 在头部追加
    if (position === 0) {
      node.next = this.head
      this.head = node
    }else{
      // 在中间追加
      // 获取当前节点的前一个节点
      let pre = this.getNode(position -1)
      node.next = pre.next
      pre.next = node
    }
    this.size++
  }

  //删除当前节点
  remove(position) {
    if (position < 0 || position >= this.size) {
      throw  new Error("Position out range")
    }
    // 定义该元素的头节点
    let current = this.head
    if (position === 0){
      this.head = current.next
    }else{
      let pre = this.getNode(position-1);
      current = pre.next
      pre.next = current.next
    }
    this.size--
  }

  //查找指定元素的索引,找到了返回索引，找不到返回-1
  indexOf(element) {
    let current = this.head
    for (let i = 0; i < this.size; i++) {
      if (current.element === element){
        return i
      }
      current = current.next;
    }
    return -1
  }

  //根据索引获取下一个元素
  getNode(index) {
    if (index < 0 || index >= this.size) {
      throw  new Error("out range")
    }
    let current = this.head
    for (let i = 0; i < index; i++) {
      current = current.next;
    }
    return current
  }
}

let l1 = new LinkedList()
l1.append(1)
l1.append(2)
l1.append(3)
l1.append(4)
l1.append(5)
l1.append(6)
l1.appendAt(2,7)
l1.remove(2)
l1.tail.next = l1.head
console.dir(l1,{
  depth:100
})
console.log(l1.indexOf(1))

4.双向循环链表