702设计链表

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

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

    // 设计双链表结构 双链表包含两个引用和一个值，一个前引用，和一个后引用
    // 引用：将某个变量赋值给引用，实际上就是将这个变量的地址赋值给引用，或者反过来说，引用中存储了这个变量的内存地址，指向了这个变量，通过引用就能找到这个变量
    public class ListNode {
        int val;
        ListNode prev;
        ListNode next;
        ListNode(int val) {
            this.val = val;
        }
    }
    // 存储的元素个数
    int size;
    ListNode head, tail;
    public MyLinkedList() {
        // 初始构造 
        // 为了减少考虑头节点和尾节点为空的边界问题，我们采用哨兵节点思路，创建两个哨兵节点
        head = new ListNode(-1);
        tail = new ListNode(-1);
        head.next = tail;
        tail.prev = head;
        size = 0;
    }
    
    public int get(int index) {
        // 1. 先判断边界
        if (index < 0 || index >= size) {
            return -1;
        }
        // 2. 由于链表不支持下标随机访问(这是和数组的不同点),为此我们采用遍历的方式获取
        ListNode p = head.next;
        //获取第index元素的for 循环如何考虑呢，举个简单例子帮助自己
        // 获取index = 0的元素，即偏移量为0的元素，即为初始位置，直接跳出循环
        for (int i = 0; i < index; i++) {
            p = p.next;
        }
        return p.val;
    }
    
    public void addAtHead(int val) {
        ListNode tmp = head.next; // 头结点
        ListNode newNode = new ListNode(val);
        head.next = newNode;
        newNode.prev = head;
        newNode.next = tmp;
        tmp.prev = newNode;
        size++;        
    }
    
    public void addAtTail(int val) {
        ListNode newNode = new ListNode(val);
        ListNode tmp = tail.prev;
        tmp.next = newNode;
        newNode.prev = tmp;
        newNode.next = tail;
        tail.prev = newNode;
        size++;
    }
    
    public void addAtIndex(int index, int val) {
        // 添加index可以添加到size大小，原因是因为添加是往前添加，元素向后移动
        if (index < 0 || index > size) {
            return;
        }
        ListNode x = new ListNode(val);
        ListNode p = head.next;
        for(int i = 0; i < index; i++) {
            p = p.next;
        }
        ListNode tmp = p.prev;
        p.prev = x;
        x.next = p;
        tmp.next = x;
        x.prev = tmp;
        size++;

    }
    
    public void deleteAtIndex(int index) {
        if (index >= size || index < 0) {
            return;
        }
        ListNode p = head.next;
        for(int i = 0; i < index; i++) {
            p = p.next;
        }
        ListNode prev = p.prev;
        ListNode next = p.next;
        prev.next = next;
        next.prev = prev;
        size--;
    }
}

单链表方式：

class MyLinkedList {
    class ListNode {
        int val;
        ListNode next;
        ListNode(int val) {
            this.val = val;
        }
    }
    ListNode head;
    int size;
    public MyLinkedList() {
        size = 0;
        head = new ListNode(-1);
    }
    
    public int get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode p = head.next;
        for (int i = 0; i < index; i++) {
            p = p.next;
        }
        return p.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;
        }
        index = Math.max(0, index);
        // 需要找到index -1 数据，然后从这里添加一个数据
        // 如果index - 1 < 0
        ListNode tmp;
        if (index - 1 < 0) {
            tmp = head;
        }else {
            tmp = getIndex(index - 1);
        }
        
        ListNode newNode = new ListNode(val);
        // 单链表需要警惕指针丢失，要先把后面节点连上，再把前面节点断开
        newNode.next = tmp.next;
        tmp.next = newNode;
        size++;
    }
    
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        // 找到index-1节点，然后index -1 节点直接连接 index +1 节点
        ListNode prev;
        if (index - 1 < 0) {
            prev = head;
        }else {
            prev = getIndex(index - 1);
        }
        prev.next = prev.next.next;
        size--;

    }

    private ListNode getIndex(int index) {
        ListNode p = head.next;
        for(int i = 0; i < index; i++) {
            p = p.next;
        }
        return p;
    }
}