JavaScript 数据结构-单向链表

最新推荐文章于 2024-10-05 12:30:18 发布
嗷呜~嗷呜~呜呜~
最新推荐文章于 2024-10-05 12:30:18 发布
阅读量1k
点赞数
分类专栏：数据结构文章标签：数据结构
本文链接：https://blog.csdn.net/weixin_63712639/article/details/123714208
版权
数据结构专栏收录该内容
7 篇文章 0 订阅
订阅专栏
<!DOCTYPE html>
<html>

<head>
    <meta charset="UTF-8">
    <title>Document</title>
    <style></style>
</head>

<body>

    <script>
        // 封装单向链表类
        function linkedList() {
            // 内部的类:用来表示每一个节点(数据,指针)
            function Node(data) {
                this.data = data //节点数据
                this.next = null //节点指针
            }

            // 属性
            this.head = null // 头指针
            this.length = 0 // 链表长度

            // 1.末尾追加方法
            linkedList.prototype.append = function (data) {
                // 1.创建新的节点
                var newNode = new Node(data)

                // 2.判断添加的是否为第一个节点
                if (this.length == 0) { //2.1是第一个节点
                    this.head = newNode
                } else { //2.2不是第一个节点
                    // 找到最后一个节点
                    var current = this.head //当前节点为头指针
                    while (current.next) {
                        current = current.next //循环,让当前节点指向下一个节点
                    }
                    // 此时的current表示最后一个节点 最后节点的next指向新的节点
                    current.next = newNode //修改最后节点的指针指向
                }

                // 3.length+1
                this.length += 1
            }

            // 2.toString方法
            linkedList.prototype.toString = function () {
                // 1.定义变量
                var current = this.head
                var listString = ''

                // 2.循环获取每一个节点
                while (current) {
                    listString += current.data + ' '
                    current = current.next
                }
                return listString
            }

            // 3.插入方法
            linkedList.prototype.insert = function (position, data) {
                // 1.判断插入的位置position是否越界
                if (position < 0 || position > this.length) {
                    return false
                }

                // 2.创建新的节点
                var newNode = new Node(data)

                // 3.判断插入位置是否是第一个
                if (position == 0) {
                    newNode.next = this.head //改变新插入节点的指针 指向原来的第一个节点
                    this.head = newNode //头指针指向新插入的节点
                } else {
                    var index = 0 //用于记录当前位置
                    var current = this.head //用于表示当前节点
                    var previous = null //用于表示上一个节点
                    while (index++ < position) { //当前位置小于插入位置就继续循环
                        previous = current //上一个节点等于当前节点
                        current = current.next //当前节点等于当前节点的下一个节点
                    }

                    newNode.next = current //循环结束,已经找到插入节点位置,插入节点的下一个节点等于当前节点
                    previous.next = newNode //上一个节点指针指向新插入的节点
                }

                // 4.长度+1
                this.length += 1
            }

            // 4.获取元素方法
            linkedList.prototype.get = function (position) {
                // 1.判断是否越界
                if (position < 0 || position >= this.length) {
                    return false
                }

                // 2.获取对应的data
                var current = this.head
                var index = 0
                while (index++ < position) { // index=0 每循环一次+1
                    current = current.next
                }

                // 此时的current就是position位置的节点
                return current.data
            }

            // 5.获取元素下标的方法
            linkedList.prototype.indexOf = function (data) {
                // 1.定义变量
                var current = this.head //用于保存当前节点 ,初始化为头结点
                var index = 0 //记录下标

                // 2.开始查找
                while (current) { //当current为null时结束循环
                    if (current.data == data) {
                        return index
                    }
                    current = current.next //一个一个节点查找
                    index += 1 //循环一次,下标+1
                }

                // 3.没有找到current,也就是current=null 返回-1
                return -1
            }

            // 6.更改某个下标的元素
            linkedList.prototype.update = function (position, newData) {
                // 1.判断是否越界
                if (position < 0 || position >= this.length) {
                    return false
                }

                // 2.定义变量
                var current = this.head
                var index = 0

                // 3.查找正确的节点
                while (index++ < position) {
                    current = current.next
                }

                //4.将position位置节点的data修改为newData
                current.data = newData
            }

            // 7.删除下标元素
            linkedList.prototype.removeAt = function (position) {
                // 1.判断是否越界
                if (position < 0 || position >= this.length) {
                    return false
                }

                // 2.定义变量
                var current = this.head
                var index = 0
                var previous = null

                // 3.判断是否删除的是第一个节点
                if (position == 0) {
                    this.head = this.head.next
                } else {
                    while (index++ < position) {
                        previous = current
                        current = current.next
                    }

                    // 4.前一个节点的next 指向,current的next
                    previous.next = current.next
                }

                // 5.长度-1
                this.length -= 1
                return current.data //返回删除元素
            }

            // 8.删除元素
            linkedList.prototype.remove = function (data) {
                // 1.获取data在链表中的位置
                var position = this.indexOf(data)

                // 2.根据位置信息,删除节点
                return this.removeAt(position)
            }

            // 9.判断是否为空链表
            linkedList.prototype.isEmpty = function () {
                return this.length == 0
            }

            // 10.获取链表长度的方法
            linkedList.prototype.size = function () {
                return this.length
            }
        }


        // 测试
        // 1.创建linkedList
        var list = new linkedList()

        // 2.测试末尾追加方法
        list.append(10)
        list.append(20)
        list.append(30)
        alert(list)

        // 3.测试插入方法
        list.insert(3, 40)
        list.insert(0, 1)
        list.insert(1, 2)
        alert(list)

        // 4.测试获取元素方法
        alert(list.get(0))
        alert(list.get(1))
        alert(list.get(2))

        // 5.测试获取下标方法
        alert(list.indexOf(1))
        alert(list.indexOf(2))
        alert(list.indexOf(3))

        // 6.测试更改下标元素的方法
        list.update(0, '更改的1号元素')
        list.update(1, '更改的2号元素')
        list.update(2, '更改的3号元素')
        alert(list)

        // 7.测试根据下标删除元素的方法
        list.removeAt(0)
        list.removeAt(0)
        list.removeAt(0)
        alert(list)

        // 8.测试根据元素删除元素的方法
        list.remove(20)
        alert(list)
        list.remove(30)
        alert(list)

        // 9.测试是否为空链表的方法
        alert(list.isEmpty())

        // 10.测试获取链表长度的方法
        alert(list.size())
    </script>
</body>

</html>