【JavaScript数据结构系列】07-循环链表CircleLinkedList

【JavaScript数据结构系列】07-循环链表CircleLinkedList

码路工人 CoderMonkey

转载请注明作者与出处

1. 认识循环链表

首节点与尾节点相连的，就构成循环链表。其中，
单向链表首尾相连构成单向循环链表，
双向链表首尾相连构成双向循环链表。

循环链表，可以无限迭代，
迭代过程即是链表头不断移动的过程。
所以迭代过程中链表头尾节点是不断变化的。

1.1 单向循环链表 CircleLinkedList

与前文讲过的单向链表的区别是，
尾节点的后继不再指向 null，而是头节点。

1.2 双向循环链表 CircleDoublyLinkedList

与前文讲过的双向链表的区别是，
头节点的前驱不再指向 null，而是尾节点，
尾节点的后继不再指向 null，而是头节点。

请看码路工人画的循环链表结构示意图：

2. 常用方法

这里，我们以【单向循环链表】为例，

实现以下常用方法：

方法	描述
append(data)	向链表添加元素
insert(position, data)	向指定位置插入元素
remove(data)	删除元素
removeAt(position)	删除指定位置元素
update(position, data)	更新指定位置元素
findAt(position)	查找指定位置元素
indexOf(data)	获取元素位置
traverse(cb, reversal)	指定方向遍历
getNext()	迭代下一个节点
head()	获取首元素数据
tail()	获取尾元素数据
size()	获取链表大小
isEmpty()	判断链表是否为空
clear()	清空链表
toString()	字符串化

单向循环链表应是继承自链表，
有些方法没有区别使用继承即可，
这里为了阅读方便就在完整代码里写全了。

在添加、插入或删除节点时，
要注意相应地改变head/tail地指向。
在遍历时，因循环链表尾节点仍有后继，
要避免无限循环，使用index<count判断。

3. 代码实现

若要查看 data-struct-js 的完整代码实现：

git clone https://github.com/CoderMonkie/data-struct-js.git
# 或
git clone https://gitee.com/coder-monkey/data-struct-js.git

若要使用 data-struct-js 的 npm 包：

npm install data-struct-js

封装单向循环链表类

/**
 * 单向循环链表
 */
function CircleLinkedList() {
    this.__head = null
    this.__tail = null
    this.__count = 0

    // 用Node表示链表内部元素
    function Node(data) {
        this.data = data
        this.next = null

        Node.prototype.toString = function () {
            return this.data.toString()
        }
    }
}

3.1 append(data)

添加节点方法

实现分析：

• 如果为空链表，头节点与尾节点的指向新添加的节点
• 然后尾节点的 next 指向头节点
• 如果是非空链表，将尾节点的 next 指向新添加的节点
• 再将尾节点指向 新添加的节点
• 再将新的尾节点的 next 指向头节点
• 添加完成，计数加1

与普通链表不同就在于要维护尾节点的 next 指向，
保持指向头节点。

// 添加节点
CircleLinkedList.prototype.append = function (data) {

  // 1. 创建新元素
  let newNode = new Node(data)

  // 2.1 链表为空时，直接添加到末尾
  if (this.isEmpty()) {
    this.__head = newNode
    this.__tail = newNode
  }
  // 2.2 链表非空时，末尾添加新元素
  else {
    this.__tail.next = newNode
    this.__tail = newNode
  }
  // 2.3 将新的尾节点的后继指向头节点
  this.__tail.next = this.__head

  // 3. 内部计数加1
  this.__count += 1

  return true
}

3.2 insert(position, data)

插入节点方法

实现分析：

• 检查插入位置，范围 0～count-1
• 创建新节点，插入位置分三种情况：
• 1.位置0：修改head指向和tail的next指向
• 2.位置count-1，同append方法
• 3.其它位置：不涉及首尾节点的指向关系，按普通插入即可

// 插入节点
CircleLinkedList.prototype.insert = function (position, data) {
  // 1.边界检查（插入位置）
  if (position < 0 || position > this.__count) return false

  // 2. 创建新元素
  var newNode = new Node(data)

  // 3.1插入到链表头部
  if (position === 0) {
    newNode.next = this.__head
    this.__head = newNode
    this.__tail.next = this.__head

    // 内部计数加1
    this.__count += 1
  }
  // 3.2插入到链表尾部
  else if (position === this.__count) {
    this.append(data)
  }
  // 3.3以外
  else {
    let previous = null
    let current = this.__head
    let index = 0
    while (index < position) {
      previous = current
      current = current.next
      index++
    }
    previous.next = newNode
    newNode.next = current

    // 内部计数加1
    this.__count += 1
  }

  return true
}

3.3 remove(data)

删除节点方法

这里调用了两个其它方法来实现。

• 1.调用 indexOf 方法找到下标
• 2.调用 removeAt 方法删除节点

// 删除节点
CircleLinkedList.prototype.remove = function (data) {

  const position = this.indexOf(data)

  if (position === -1) return false

  return this.removeAt(position)
}

3.4 removeAt(position)

删除指定位置节点

实现分析：

• 1.参数的边界检查
• 2.根据循环链表节点个数，分以下两种情况：
• 2.1只有一个节点：首尾节点全部置空即可
• 2.2多个节点的时候，分以下三种情况：
• 2.2.1删除头节点
  • 将删除对象的前驱与后继相连
  • 更新头节点指向
  • 重新首尾相连（更新尾节点next指向）
• 2.2.2删除尾节点
  • 将删除对象的前驱与后继相连
  • 更新尾节点指向
• 2.2.3删除其它节点：
  • 将删除对象的前驱与后继相连
  • 三种情况下此处理相同

// 删除指定位置节点
CircleLinkedList.prototype.removeAt = function (position) {
  // 1.边界检查
  if (position < 0 || position >= this.__count) return false

  // 2.1.链表中只要一个元素的时候
  if (this.__count === 1) {
    // position 只能是 0
    this.__head = this.__tail = null
  }
  // 2.2.链表中有多个元素的时候
  else {
    let index = 0
    let previous = null
    let current = this.__head

    // 2.2.1.找到指定位置元素
    while (index++ < position) {
      previous = current
      current = current.next
    }
    // 2.2.2.使当前元素不再被引用(当删除的不是头节点)
    previous && (previous.next = current.next)

    // A. 如果删除的是头节点
    if (position === 0) {
      // 更新 head 的指针
      this.__head = current.next
      // 重新连接首尾
      this.__tail.next = this.__head
    }
    // B. 如果删除的是尾节点
    else if (position === this.__count - 1) {
      // 更新 tail 的指针
      this.__tail = previous
    }
  }

  // 3.内部计数减1
  this.__count -= 1

  return true
}

3.5 update(position, data)

更新节点

实现分析：

• 更新方法不涉及首尾节点指向关系
• 与普通链表的更新处理相同

// 更新节点
// 因不涉及指向问题，更新方法与LinkedList相同
// 实际开发中使用继承自 CircleLinkedList 的 update 方法
CircleLinkedList.prototype.update = function (position, data) {
  // 1.边界检查
  if (position < 0 || position >= this.__count) return false

  var current = this.__head
  var index = 0

  // 2.找到指定位置元素
  while (index++ < position) {
    current = current.next
  }
  // 3.修改当前元素数据
  current.data = data

  // 4.修改完成，返回 true
  return true
}

3.6 findAt(position)

获取指定位置节点的数据

// 获取指定位置节点
CircleLinkedList.prototype.findAt = function (position) {
  // 边界检查
  if (position < 0 || position >= this.__count) return

  var index = 0
  var current = this.__head

  while (index < position) {
    current = current.next
    index += 1
  }
  return current.data
}

3.7 indexOf(data)

获取下标

// 获取下标
CircleLinkedList.prototype.indexOf = function (data) {
  var current = this.__head
  var index = 0

  // 根据指点数据查找节点元素，探查到尾节点后需停止
  while (index < this.__count) {
    if (current.data == data) {
      return index
    }
    current = current.next
    index += 1
  }

  return -1
}

3.8 traverse(callback)

遍历函数

// 遍历链表
CircleLinkedList.prototype.traverse = function(callback) {
  // 参数检查（回调函数）
  if (!callback || toString.call(callback) !== '[object Function]') return

  // 计数
  let index = 0
  // 起始元素设为 head
  let current = this.__head

  // 头部起始，向后遍历，到链表尾结束
  while (index < this.__count) {
    callback(current.data)
    current = current.next
    index += 1
  }
}

3.9 getNext()

迭代函数

/**
 * 迭代下一个节点
 * 即链表头节点指针后移
 *
 * @returns 所在节点数据
 * @memberof CircleLinkedList
 */
CircleLinkedList.prototype.getNext = function() {
  if (this.isEmpty()) return undefined
  let current = this.__head
  if (this.__count > 1) {
    this.__head = current.next
    this.__tail = current
  }
  return current.data
}

3.10 其它方法

其它方法大都与链表方法一致（toString的循环条件不同）
一并放在完整代码里。

/**
 * 链表：单向循环链表
 */
function CircleLinkedList() {
    // 记录链表首个元素
    this.__head = null
    this.__tail = null
    this.__count = 0

    // 用Node表示链表内部元素
    function Node(data) {
        this.data = data
        this.next = null

        Node.prototype.toString = function () {
            return this.data.toString()
        }
    }

    // 添加节点
    CircleLinkedList.prototype.append = function (data) {

        // 1. 创建新元素
        let newNode = new Node(data)

        // 2.1 链表为空时，直接添加到末尾
        if (this.isEmpty()) {
            this.__head = newNode
            this.__tail = newNode
        }
        // 2.2 链表非空时，末尾添加新元素
        else {
            this.__tail.next = newNode
            this.__tail = newNode
        }
        // 2.3 将新的尾节点的后继指向头节点
        this.__tail.next = this.__head

        // 3. 内部计数加1
        this.__count += 1

        return true
    }

    // 插入节点
    CircleLinkedList.prototype.insert = function (position, data) {
        // 1.边界检查（插入位置）
        if (position < 0 || position > this.__count) return false

        // 2. 创建新元素
        var newNode = new Node(data)

        // 3.1插入到链表头部
        if (position === 0) {
            newNode.next = this.__head
            this.__head = newNode
            this.__tail.next = this.__head

            // 内部计数加1
            this.__count += 1
        }
        // 3.2插入到链表尾部
        else if (position === this.__count) {
            this.append(data)
        }
        // 3.3以外
        else {
            let previous = null
            let current = this.__head
            let index = 0
            while (index < position) {
                previous = current
                current = current.next
                index++
            }
            previous.next = newNode
            newNode.next = current

            // 内部计数加1
            this.__count += 1
        }

        return true
    }

    // 删除节点
    CircleLinkedList.prototype.remove = function (data) {

        const position = this.indexOf(data)

        if (position === -1) return false

        return this.removeAt(position)
    }

    // 删除指定位置节点
    CircleLinkedList.prototype.removeAt = function (position) {
        // 1.边界检查
        if (position < 0 || position >= this.__count) return false

        // 2.1.链表中只要一个元素的时候
        if (this.__count === 1) {
            // position 只能是 0
            this.__head = this.__tail = null
        }
        // 2.2.链表中有多个元素的时候
        else {
            let index = 0
            let previous = null
            let current = this.__head

            // 2.2.1.找到指定位置元素
            while (index++ < position) {
                previous = current
                current = current.next
            }
            // 2.2.2.使当前元素不再被引用(当删除的不是头节点)
            previous && (previous.next = current.next)

            // A. 如果删除的是头节点
            if (position === 0) {
                // 更新 head 的指针
                this.__head = current.next
                // 重新连接首尾
                this.__tail.next = this.__head
            }
            // B. 如果删除的是尾节点
            else if (position === this.__count - 1) {
                // 更新 tail 的指针
                this.__tail = previous
            }
        }

        // 3.内部计数减1
        this.__count -= 1

        return true
    }

    // 更新节点
    // 因不涉及指向问题，更新方法与LinkedList相同
    // 实际开发中使用继承自 CircleLinkedList 的 update 方法
    CircleLinkedList.prototype.update = function (position, data) {
        // 1.边界检查
        if (position < 0 || position >= this.__count) return false

        var current = this.__head
        var index = 0

        // 2.找到指定位置元素
        while (index++ < position) {
            current = current.next
        }
        // 3.修改当前元素数据
        current.data = data

        // 4.修改完成，返回 true
        return true
    }

    // 获取指定位置节点
    CircleLinkedList.prototype.findAt = function (position) {
        // 边界检查
        if (position < 0 || position >= this.__count) return

        var index = 0
        var current = this.__head

        while (index < position) {
            current = current.next
            index += 1
        }
        return current.data
    }

    // 获取下标
    CircleLinkedList.prototype.indexOf = function (data) {
        var current = this.__head
        var index = 0

        // 根据指点数据查找节点元素，探查到尾节点后需停止
        while (index < this.__count) {
            if (current.data == data) {
                return index
            }
            current = current.next
            index += 1
        }

        return -1
    }

    // 遍历链表
    CircleLinkedList.prototype.traverse = function(callback) {
        // 参数检查（回调函数）
        if (!callback || toString.call(callback) !== '[object Function]') return

        // 计数
        let index = 0
        // 起始元素设为 head
        let current = this.__head

        // 头部起始，向后遍历，到链表尾结束
        while (index < this.__count) {
            callback(current.data)
            current = current.next
            index += 1
        }
    }

    /**
     * 迭代下一个节点
     * 即链表头节点指针后移
     *
     * @returns 所在节点数据
     * @memberof CircleLinkedList
     */
    CircleLinkedList.prototype.getNext = function() {
        if (this.isEmpty()) return undefined
        let current = this.__head
        if (this.__count > 1) {
            this.__head = current.next
            this.__tail = current
        }
        return current.data
    }

    // 获取节点个数
    CircleLinkedList.prototype.size = function () {
        return this.__count
    }

    // 是否空链表
    CircleLinkedList.prototype.isEmpty = function () {
        return this.__count === 0
    }

    // 清空链表
    CircleLinkedList.prototype.clear = function () {
        this.__head = null
        this.__count = 0
    }

    // 获取字符串
    CircleLinkedList.prototype.toString = function () {
        let str = '[ '
        let index = 0
        let current = this.__head
        while (index < this.__count) {
            str += current + ' -> '
            current = current.next
            index += 1
        }
        str += ` | Count: ${this.__count} ]`
        return str
    }
}

4. 使用

// ---------------------------------------------
// Test: CircleLinkedList
// ---------------------------------------------
console.log('----Test: CircleLinkedList----')

var circle = new CircleLinkedList()

circle.append("1.Plan")
circle.append("2.Do")
circle.append("3.Check")
circle.append("4.Act")

for (let j = 0; j < 4; j++) {
    const item = circle.getNext()
    console.log(`${j} : ${item}`)
}

circle.traverse(item=>{
    console.log(`Traversing : ${item}`)
})

console.log('---------------------')
circle.remove('2.Do')
console.log(`After remove element 2.Do : ${circle}`, )
circle.removeAt(2)
console.log(`After removeAt(2): ${circle}`)

----Test: CircleLinkedList----
0 : 1.Plan
1 : 2.Do
2 : 3.Check
3 : 4.Act
Traversing : 1.Plan
Traversing : 2.Do
Traversing : 3.Check
Traversing : 4.Act
---------------------
After remove element 2 : [ 1.Plan -> 3.Check -> 4.Act ->  | Count: 3 ]
After removeAt(2): [ 1.Plan -> 3.Check ->  | Count: 2 ]

以上。

---

做了一份 npm 工具包 data-struct-js ，
基于 ES6 实现的 JavaScript 数据结构，
虽然这个小轮子很少会被使用，
也许对于初学者学习 JavaScript 会有点帮助。
只要简单 install 一下即可，感兴趣的话还可以去
GitHub / Gitee 看源码。（Star 表支持～）

npm install data-struct-js --save-dev

https://github.com/CoderMonkie/data-struct-js
https://gitee.com/coder-monkey/data-struct-js

最后，感谢您的阅读和支持~

---

-end-