设计链表啊

猴子的救兵啊

已于 2023-04-10 22:47:45 修改

阅读量57

点赞数

分类专栏：算法文章标签：链表数据结构 java

于 2023-04-10 22:46:12 首次发布

本文链接：https://blog.csdn.net/m0_65221362/article/details/130071345

版权

算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章讨论了如何设计一个链表数据结构，包括单链表和双链表，实现添加节点（头插法、尾插法、指定位置插入）、获取节点值和删除节点等操作。在实现中，采用了带虚拟头节点的单链表，对下标的理解和处理是关键，下标从0开始。

摘要由CSDN通过智能技术生成

707. 设计链表

中等

802

相关企业

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

MyLinkedList() 初始化 MyLinkedList 对象。
int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

示例：

输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3

class MyLinkedList {
    //存储个数
    int size;
    //虚拟头节点
       ListNode head;

    public MyLinkedList() {
        this.size = 0;
        this.head = new ListNode(0);

    }
    
    public int get(int index) {
        if(index<0||index>=size){
            return -1;
        }
        ListNode cur=head;
        for(int n=0;n<=index;n++){
            cur=cur.next;
        }
        return cur.val;
      
    }
    
    public void addAtHead(int val){
         addAtIndex(0,val);
       }
    
    public void addAtTail(int val) {
       addAtIndex(size,val);
    }
    
    public void addAtIndex(int index, int val) {
        if(index>size){
            return;
        }
        if(index<0){
         index=0;
        }
        size++;

        ListNode pre=head;
        for(int n=0;n<index;n++){
            pre=pre.next;
        }
            ListNode addNode =new ListNode(val);
            addNode.next=pre.next;
            pre.next=addNode;
           
    }
    
    public void deleteAtIndex(int index) {
      if(index < 0 || index >= size){
          return;
      }
      size--;
      if(index==0){
          head=head.next;
          return;
      }
      ListNode pred=head;
      for(int n=0;n<index;n++){
          pred=pred.next;
      }
      pred.next=pred.next.next;


    }
}

当初我是不理解怎么定义下标的，为什么1->2->3,的1下标为0

我的看法：眼见为实，我们看这个代码返回值的方法get

  public int get(int index) {
        if(index<0||index>=size){
            return -1;
        }
        ListNode cur=head;
        for(int n=0;n<=index;n++){
            cur=cur.next;
        }
        return cur.val;
      
    }


    public MyLinkedList() {
        this.size = 0;
        this.head = new ListNode(0);

    }

上面两个代码可以知道我们这个代码是有一个虚拟头节点，但是这个节点是确确实实有空间有值的，当我们添加1时，底层是0->1,为什么1下标是0不是1，我们看for循环，我们设置了一个指针，指向了0（底层是指向0的那个地址空间，我们简略一下），当我们要获取下标0的值的时候，for循环是执行了一次的，如果我们只是小于index,那么这个1的下标就变成1了，而下标0是那个虚拟头节点也就是0；

public void addAtIndex(int index, int val) {
        if(index>size){
            return;
        }
        if(index<0){
         index=0;
        }
        size++;

        ListNode pre=head;
        for(int n=0;n<index;n++){
            pre=pre.next;
        }
            ListNode addNode =new ListNode(val);
            addNode.next=pre.next;
            pre.next=addNode;
           
    }

然后我们看看添加方法，这里的for循环没有等于，也就是说，此时我们的指针是指向0的（假如我们要往下标1的地方添加一个值为2的节点），因为我们链表添加是往前一位的，所以原来下标，而这里并不是替换，假如我们原来下标1值为3，这里并不是把住在下标1房间（地址）的3踢出去，而是重新创造了一个空间，把 2放在1了，但是这样他们的地址并不连续了

1，2，3的地址分别是ListNode@751;753;752,所以链表在地址中并不是连续分布的，而是随机分布在内存各个节点当中，依靠那个线相连（next）术语好像叫指针域的指针，我印象里面好像数组是在内存中连续分布的