基于javaScript ES6实现单链表

代码未经优化，望各位参考者指正

如下：

class LinkList {
    constructor(data) {
        this.data = data
        this.next = null
        this.head = null
        this.length = 0
    }

    // 尾插法
    append(data) {
        const NewNode = new LinkList(data) //创建一个新节点
        if (this.length == 0) { //当头指针未指向的元素的时候，代表 length 为 0
            this.head = NewNode
        } else { //若头指针已经指向了元素，则我们需要找到被指向的元素的 next 也就是尾指针
            let current = this.head
            while (current.next) { //寻找尾指针
                current = current.next
            }
            current.next = NewNode //若头指针未指向任何元素，则让头指针指向新创建的节点元素
        }
        this.length++
    }

    // 头插法
    insertElement(data) {
        let NewNode = new LinkList(data)
        NewNode.next = this.head //由于head本来保存的就是原来第一个的地址
        this.head = NewNode //再让头指针指向新节点
        this.length++
    }

    // 指定下标插入法
    piontIndexInsertElement(data, position) {
        let count = 0;
        let current = this.head
        let privous = null //为了保存被插入元素位置前元素的地址
        let NewNode = new LinkList(data)
        if (position > 0 && position < this.length) { //内部插入法
            while (current.next) {
                count++
                privous = current //得到指定的元素位置之前的地址
                current = current.next //遍历链表
                if (count === position) { //若count记录到 3 说明循环执行了三次
                    break;
                }
            }
            NewNode.next = current //current保存的是指定的位置下一个元素的地址
            privous.next = NewNode //再让指定的位置前面的元素地址指向新元素
            this.length++
        } else if (position > this.length) { //尾插
            while (current.next) {
                current = current.next
            }
            current.next = NewNode
            this.length++
        }

    }

    // 传入下标返回链表元素值
    getElement(num) {
        if (num > this.length || num < 0) {
            return '越界!'
        } else {
            let current = this.head
            while (num++ < this.length) { //寻找
                current = current.next
            }
            return current.data
        }

    }

    // 传入元素得到该下标
    getIndexOf(data) {
        let current = this.head;
        let count = 0;
        while (current.next) {
            current = current.next
            if (current.data == data) {
                break;
            }
            count++
        }
        if (current.data !== data) {
            return '链表无该元素'
        }
        return count
    }

    // 修改指定元素的内容
    updataElement(data) {
        let current = this.head;
        while (current.next) {
            current = current.next
            if (current.data === data) {
                break;
            }
        }
        if (current.data !== data) {
            return '链表内无该元素'
        }
        return current.data = `${data}被修改了`

    }

    // 传入元素删除链表内指定元素
    removeAtElement(data) {
        let current = this.head;
        let privous = null;
        while (current.next) {
            privous = current
            current = current.next
            if (current.data === data) {
                break;
            }
        }
        if (current.data !== data) {
            return '链表本无该元素，无法删除'
        } else {
            if (current.next === null) { //若要删除的元素为尾节点，则将要删除的元素地址指向空
                current.next = null
                current.data = ''
            } else {
                privous.next = current.next //让指定元素上个元素的地址指向该元素位置的下一个元素
            }
            this.length--
        }

    }

    // 传入下标删除指定元素
    removeAtElementAboutIndex(index) {
        let current = this.head
        let count = 0;
        let privous = null
        if (index < 0 || index > this.length - 1) {
            throw new LinkList(Error('无法删除，下标越界'))
        } else {
            if (current.next) {
                while (current.next) {
                    count++
                    privous = current
                    current = current.next
                    if (count === index) {
                        break;
                    }

                }
                if (current.next == null) { //当要删除的元素是末尾元素时
                    current.data = ''
                    current.next = null
                } else { //当要删除的元素非末尾元素时
                    privous.next = current.next
                }
                this.length--
            }
        }
    }

    // 判断链表是否为空，为空返回false 否则返回 true
    isEmptyElement() {
        return `${this.length === 0}：false 为空 true不为空`
    }

    // 计算链表的长度
    size() {
        return `链表长度为:${this.length}`
    }

    // 重置链表
    resetLinkedList() {
        this.head.next = null
        this.length = 0
    }

    // 打印链表
    printAllOfElement() { //打印链表元素
        let result = ''
        let current = this.head
        while (current) {
            result += current.data + ' '
            current = current.next
        }
        return result
    }
}
const linkList = new LinkList()
linkList.insertElement('我是头插法') //头插法

// 尾插法
linkList.append('瞿盟')
linkList.append('汪洋')
linkList.append('方景顺')
linkList.append('张磊')

//指定插入到第三个元素之后第四个元素之前
linkList.piontIndexInsertElement('我是指定位置插入', 4)
    //传入下标寻找元素
alert(linkList.getElement(3))
    //获得指定元素的下标
alert(linkList.getIndexOf('方景顺'))
    //传入元素修改指定元素的值
alert(linkList.updataElement('瞿盟'))
    //重置链表
    // linkList.resetLinkedList()
    //传入下标值删除对应下标的元素
linkList.removeAtElementAboutIndex(1)
    //打印整个链表
alert(linkList.printAllOfElement())
    // 获取链表的长度
alert(linkList.size())
    //判断链表是否为空
alert(linkList.isEmptyElement())