数据结构：链表，算法题：反转单向链表

链表

• 物理结构，类似于数组
• 数组需要一段连续的内存区间，而链表是零散的
• 链表节点的数据结构 { value, next?, prev? }

链表 vs 数组

• 都是有序结构
• 链表：查询慢O(n)，新增和删除快O(1)
• 数组：查询快O(1)，新增和删除慢O(n)
• 链表实现队列更快一些

反转单向链表

/**
 * @description 反转单向链表
 * @author lsr
 */

interface ILinkListNode {
  value: number
  next?: ILinkListNode
}

/**
 * 使用数组创建单向链表
 * @param arr
 * @returns
 */
export function createLinkList(arr: number[]): ILinkListNode {
  const len = arr.length
  if (!arr.length) throw new Error('arr is empty')

  let curNode: ILinkListNode = {
    value: arr[len - 1]
  }
  if (len === 1) return curNode

  for (let i = len - 2; i >= 0; i--) {
    curNode = {
      value: arr[i],
      next: curNode
    }
  }

  return curNode
}

/**
 * 反转单向链表
 * @param linkListHead
 * @returns 反转之后的结果
 */
export function reverseLinkList(linkListHead: ILinkListNode): ILinkListNode {
  let curNode: ILinkListNode | undefined = undefined
  let prevNode: ILinkListNode | undefined = undefined
  let nextNode: ILinkListNode | undefined = undefined

  curNode = linkListHead
  nextNode = curNode.next
  curNode.next = undefined
  while (nextNode) {
    if (!curNode.next) delete curNode.next
    prevNode = curNode
    curNode = nextNode
    nextNode = curNode.next
    curNode.next = prevNode
  }

  return curNode
}

// const linkList = createLinkList([100, 200, 300, 400])
// const reverseLink = reverseLinkList(linkList)
// console.log(linkList)
// console.log(reverseLink)

单元测试

/**
 * @description 反转单向链表 test
 * @author lsr
 */

import {
  createLinkList,
  reverseLinkList
} from '@/01-algorithm/reverse-link-list'

describe('反转单向链表', () => {
  it('单个元素', () => {
    const node = createLinkList([100])
    const node1 = reverseLinkList(node)
    expect(node1).toEqual({ value: 100 })
  })

  it('多个元素', () => {
    const node = createLinkList([100, 200, 300])
    const node1 = reverseLinkList(node)
    expect(node1).toEqual({
      value: 300,
      next: {
        value: 200,
        next: {
          value: 100
        }
      }
    })
  })
})