【前端单向链表的实现】反转链表

最新推荐文章于 2022-11-19 20:53:08 发布

a黑大帅｀

最新推荐文章于 2022-11-19 20:53:08 发布

阅读量170

点赞数

分类专栏：链表文章标签：链表前端数据结构

本文链接：https://blog.csdn.net/www569006806/article/details/125325033

版权

链表专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文详细介绍了链表的数据结构特性，如内存管理的灵活性和动态扩展性，以及在插入和删除操作上的高效性。同时，讨论了链表相较于数组的访问效率问题。文章还提供了单链表的实现，包括添加、插入、查找索引和删除元素的方法。最后，展示了两种不同的链表反转算法，一种基于迭代，另一种采用递归。这些实现有助于理解链表操作的底层逻辑。

摘要由CSDN通过智能技术生成

单向链表

内存空间不是必须连续的，可以充分利用计算机的内存，实现灵活的内存动态管理。
链表不需要再创建的时候就确定大小，并且它的大小可以无限的延伸下去。
链表在插入和删除数据时，时间复杂度(即执行算法所需要的计算工作量)可以达到O(1)，相对数组效率高许多。

链表相对于数组的缺点在于：

链表访问任何一个位置的元素时，都需要从头开始访问
无法像数组一样通过下标值访问元素，需要从头开始访问，直到找到对应的元素

主要实现一下方法：

append 添加
appendCha() 插入
indexOf 返回索引
remove 删除某一项

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

class LinkedList {
  constructor(){
    this.head = null
    this.size = 0
  }

  append(element){
    let node = new Node(element)
    if(!this.head){
      this.head = node
    }else{
      let current = this.getNode(this.size - 1)
      current.next = node
    }

    this.size++
  }

  appendAt(position,element){
    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
    }
  }

  remove(position){
    if(size < 0 || position >= this.size){
      throw new Error('不合法')
    }
    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('不合法')
    }
    let current = this.head
    for(let i = 0; i<index; i++){
      current = current.next
    }
    return current
  }
}

链表反转

第一种思路是每次复制一遍头部，然后追加到新的链表尾部，通过循环就能达到

reverse(){
  let head = this.head
  let newHead = null

  while(head != null){
    let temp = head.next
    head.next = newHead
    newHead = head
    head = temp
  }
  
  this.head = newHead
  return this.head
}

第二种思路利用递归冒泡法拿到上次的闭包钩住的值进行互换，说多了也听不懂，直接上代码

reverse(){
  const reverse = (head) => {
    if(head === null || head.next === null) return head
    const current = reverse(head.next)
    head.next.next = head
    head.next = null
    return current
  }

  this.head = reverse(this.head)
  return this.head
}