力扣707设计链表 Java版本

题目

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

单链表中的节点应该具备两个属性：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

提示：

0 <= index, val <= 1000
请不要使用内置的 LinkedList 库。
调用 get、addAtHead、addAtTail、addAtIndex 和 deleteAtIndex 的次数不超过 2000 。

解题思路

代码的注释中写的比较详细了，就直接看代码吧

Code

//定义节点的结构
class ListNode {
    int val;
    ListNode next;
    ListNode(){}
    ListNode(int val){this.val=val;}
    ListNode(int val,ListNode next){
        this.val = val;
        this.next = next;

    }
}

class MyLinkedList {

    //虚拟的头节点
    ListNode dummyHead;
    //节点的个数
    int size = 0;

    public MyLinkedList() {
        dummyHead = new ListNode();
        dummyHead.next=null;
        size=0;
    }

    public int get(int index) {
        if(index<0||(index>(size-1))){
            return -1;
        }
        //定义一个负责遍历的节点
        ListNode r=dummyHead;
        //如果index小于零，则表示当前位置就是要查找的位置，所以跳出循环
        while (index>=0){
            r = r.next;
            index--;
        }
        return r.val;
    }

    public void addAtHead(int val) {
        ListNode newNode = new ListNode(val);
        //将新节点指向原始的第一个节点
        newNode.next = dummyHead.next;
        //然后将虚拟的头节点指向新的节点
        dummyHead.next = newNode;
        size++;
    }

    public void addAtTail(int val) {
        //定义一个负责遍历的节点找到最后一个节点
        ListNode r = dummyHead;
        while (r.next!=null){
            r = r.next;
        }
        //在最后一个节点之后再插入一个新的节点
        ListNode newNode = new ListNode(val);
        r.next = newNode;
        newNode.next=null;
        //size加一
        size++;
    }

    public void addAtIndex(int index, int val) {
        //如果index比长度大就不会插入到链表当中
        if (index>size){
            return;
        } else if (index==size) {//如果index等于链表的长度，那么就插入到尾部
            addAtTail(val);
        }else {//其他情况需要遍历之后，插入到下表为index的节点之前
            ListNode r = dummyHead;
            while (index>0){//因为是插入到原有位置的节点之前，所以是index等于0的时候就跳出循环
                r = r.next;
                index--;
            }
            //创建一个新的节点
            ListNode newNode = new ListNode(val);
            newNode.next = r.next;
            r.next=newNode;
            size++;
        }
    }

    public void deleteAtIndex(int index) {
        //下标无效的话，直接return
        if(index<0||(index>size-1)){
            return;
        }
        //遍历之后删除指定的节点
        ListNode r = dummyHead;
        while (index>0){
            r = r.next;
            index--;
        }
        r.next = r.next.next;//因为Java有自动垃圾回收机制，所以不释放删除节点的资源也可以
        size--;
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */