js数据结构实现单向链表

我叫汪枫
已于 2024-03-28 06:42:59 修改
阅读量137
点赞数
文章标签：链表 javascript 数据结构
于 2023-02-25 21:37:48 首次发布
本文链接：https://blog.csdn.net/weixin_47121832/article/details/129220911
版权
Js实现单向链表

详细的解析在注释中
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
    <!-- 
        链表:
        在每个语言中都有数组结构，数组在添加元素的时候消耗内存性能不高，数组能通过index获取对应的元素
        链表他在内存中不是一个连续的空间，他是分布的，在添加元素时候性能比较高，但是链表不能通过index获取对应的数据
        后期的对于大量数据的改写或者添加优势比数组明显、

        在链表中数据不单单是一个iteml其中还有一个next方法用来指向下一个元素
        其中还有的header方法用来指向第一个元素
     -->
  </head>
  <body>
    <script>
      function LinkedList() {
        // 创建一个内部类用来封装节点
        function Node(data) {
          this.data = data;
          this.next = null; //默认的话我们的next是null类型
        }
        // 创建一个头部用于指向链表的第一个元素
        this.header = null;
        this.length = 0;
        // 1、append方法---向链表尾部添加一个元素
        LinkedList.prototype.append = function (data) {
          // 创建一个新的节点
          var newNode = new Node(data);
          // 判断一下是不是当前添加是不是第一个元素
          if (this.length === 0) {
            this.header = newNode;
          } else {
            // 如果不是第一次添加我们需要进行以下操作
            var current = this.header; //header指向第一个元素
            while (current.next) {
              // 当，当前这个节点的下一个元素存在的时候，我们把当前节点替换为当前节点存在的元素
              current = current.next;
            }
            // 当一遍循环过后我们就拿到了next指向为null的元素
            current.next = newNode;
          }
          this.length += 1;
        };
        // 2、实现toString方法
        LinkedList.prototype.toString = function () {
          let result = "";
          let fristElement = this.header;
          while (fristElement) {
            result += fristElement.data + "";
            fristElement = fristElement.next;
          }
          return result;
        };
        // 3、实现插入方法
        LinkedList.prototype.inster = function (data, position) {
          // 根据传入的数据创建一个新的节点
          var newNode = new Node(data);
          // 首先我们需要对传入的位置进行判断一下
          if (position == 0 || position > this.length) {
            alert("插入位置不合法");
            return false;
          }

          // 如果传入的位置为0我们就放到最前面
          if (position == 0) {
            newNode.next = this.header; //this.header是第一位元素我们把当前的元素的next指向当前的元素
            this.header = newNode; //把第一位元素替换为当前的元素
          } else {
            let index = 0; //假设一个index为0后期给配合positin做循环
            let current = this.header; //获取一下第一个元素用来当做循环内容
            let preElement = null; //创建上一个元素
            while (index++ < position) {
              /*
              解析:比如我们需要在第四位插入元素 那么position为4
              从0开始循环判断到第三位停止
              0123刚好为第五个位置

              四次循环的解析:
              情况一、当前链表有八个元素 我要在第四位放个新元素
              0 perElement=原链表第null个元素(因为current为第一个元素) current=原链表第一个元素
              1 preElement=原链表第一个元素(因为current被替换了)     current=原链表第二个元素
              2 preElement=原链表第二个元素(因为current被替换了)     current=原链表第三个元素
              3 preElement=原链表第三个元素(因为current被替换了)     current=原链表第四个元素
              如果是这样的话:
              那么 preElement=原链表第三个元素 因为3是从2上面拿的current
                   current = current.next = 原链表第三个元素.next = 原链表第四个元素
                   newNode.next指向原链表第四个元素 因为当while执行结束后current已经变成第四个元素了
                   preElement.next=原链表第三个元素.next=newNode(刚好放到了原链表第四位)

              情况二、当前链表有四个元素，我要在第四个位置添加新元素
              0 perElement=原链表第null个元素(因为current为第一个元素) current=原链表第一个元素
              1 preElement=原链表第一个元素(因为current被替换了)     current=原链表第二个元素
              2 preElement=原链表第二个元素(因为current被替换了)     current=原链表第三个元素
              3 preElement=原链表第三个元素(因为current被替换了)     current=原链表第四个元素

              如果是这样的话：
              那么 preElement=原链表第三个元素
                  current=null---因为没有这个元素了
                  newNode.next=null因为他就是最后一个元素
                  preElement.next =原链表第三个元素.next=新元素
               */
              // 循环条件是从0开始获取元素直到当前的位置索引
              // 让插入位置的上一个元素为preElement
              preElement = current;
              current = current.next;
            }
            // 让新元素指向后一个元素
            newNode.next = current;
            preElement.next = newNode;
          }
          this.length += 1;
          // return true;
        };
        // 4、get方法：获取某个位置的元素
        LinkedList.prototype.get = function (position) {
          // 越界判断
          /*
          position比如大于0和大于等于原长度
          这里我们不能获取和链表长度一样的元素因为下标是从0开始的
           */
          if (position < 0 || position >= this.length) {
            return null;
          } else {
            var current = this.header; //获取第一位元素
            var index = 0; //创建一个循环条件
            while (index < position) {
              current = current.next;
              index++;
            }
            return current.data;
          }
        };
        // 5、indexOf：更据data获取对应的位置
        LinkedList.prototype.indexOf = function (data) {
          var current = this.header;
          var index = 0;
          // 开始查找
          while (current) {
            // 如果当前的current中的data等于传入的data那么他就是我们要找的
            if (current.data === data) {
              return index;
            }
            current = current.next;
            index++;
          }
          // 如果都没有就返回-1
          return -1;
        };
        // 6、update方法：更据传入的位置改变对应位置的元素
        LinkedList.prototype.update = function (position, element) {
          if (position < 0 || position >= this.length) {
            return false;
          } else {
            // 查找正确的节点
            var current = this.header;
            var index = 0;
            while (index++ < position) {
              current = current.next;
            }
            current.data = element;
          }
        };
        // 7、removeAt：移除某个位置的元素
        LinkedList.prototype.removeAt = function (position) {
          // 越界判断
          if (position < 0 || position >= this.length) {
            return null;
          } else {
            if (position == 0) {
              // 移除位置为0的操作
              this.header = this.header.next;
              // 让header的指向指向第一个元素的后一位 不用担心第一位，因为在js中会有垃圾回收机制
            } else {
              // 和获取元素的逻辑基本一致先创建一系列的循环条件
              var index = 0;
              var current = this.header;
              while (index++ > position) {
                current = current.next; //让他去寻找到适合自己的位置
              }
              current.next = current.next.next; //找到我们需要的位置元素以后，我们对他调用两次next方法让他指向下一个元素
              this.length--;
            }
          }
        };
        // 8、remove；根据元素的内容删除元素
        LinkedList.prototype.remove = function (data) {
          // 根据data获取链表元素的位置
          var position = this.indexOf(data);
          this.length--;
          return this.removeAt(position);
        };
        // 9、isEmpty方法，判断链表是否为空
        LinkedList.prototype.isEmpty = function () {
          return this.length === 0;
        };
        // 10、size方法 用于返回链表的大小
        LinkedList.prototype.size = function () {
          return this.length;
        };
      }

      let list = new LinkedList();
      list.append("1");
      list.append("2");
      list.append("3");
      // list.inster("new1", 1);
      // console.log(list);
      // console.log(list.get(1));
      // console.log(list.indexOf("new1"));
      // list.update(1, "123");
      // console.log("1233");
      // console.log(list);
      // list.removeAt(1);
      // console.log(list);
      list.remove("1");
      alert(list.isEmpty());
      alert(list.size());
      console.log(list);
    </script>
  </body>
</html>