【刷题日志】Day1.链表（设计链表、反转链表、两两交换链表）

1设计一个链表

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。
在链表类中实现这些功能：
get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

题解：我们设计一个虚拟头节点来解决这个问题，不妨先解决addAtIndex(index,val）这个方法

我们假设如果此时是空链表，那么此时新添加的节点就是头节点

同时如果新添加的索引是链表的长度，那么此时就应该直接加到最后一个节点后面

如果不是上面的两种情况，那么我们应该先找到索引所对应到前一个的节点然后再修改指向

我们可以用for循环来找到这个索引所对应的节点

        for(int i = 0;i < index;i++){
            cur = cur.next;//cur是指针
        }

然后我们再修改节点的指向就可以在链表中间添加节点了

        node.next = cur.next;
        cur.next = node;

运用同样的思路我们可以也把deleteAtIndex(index)这个方法解决了

还是一样我们先找到所对应索引的前一个节点然后修改指向

        for(int i = 0;i < index;i++){
            cur = cur.next;
        }
        cur.next = cur.next.next;

最后我们来将get这个方法写完

思路还是一样的先找到索引对应的节点所以此时我们的for循环应该这样来写

        for(int i = 0;i <= index;i++){
            cur = cur.next;
        }

由于我们使用了一个虚拟头节点所以我们的 i 应该写成 = index 这样我们才能找到对应的节点

最后贴上我们的代码

class MyLinkedList {

    class ListNode{
        ListNode next;
        int val;
        
        ListNode(int val){
            this.val = val;
        }
    }

    ListNode head;
    ListNode tail;
    int size;
    
    public MyLinkedList() {
        head = new ListNode(0);
        size = 0;
    }

    public int get(int index) {
        if(index >= size || index < 0){
            return -1;
        }
        ListNode cur = head;
        for(int i = 0;i <= index;i++){
            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) {
        ListNode node = new ListNode(val);
        ListNode cur = head;

        if(size < index){
            return;
        }

        if(index < 0){
            index = 0;
        }

        for(int i = 0;i < index;i++){
            cur = cur.next;
        }
        size++;
        node.next = cur.next;
        cur.next = node;
    }

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

2反转一个链表

反转链表的核心在于遍历链表的同时不断的修改每个节点的指向，直到我们的链表遍历结束

那么我们要遍历链表就应该使用while循环来进行遍历，那么我们的遍历结束条件是什么？

我画了一个图来模拟完成反转链表的过程，使用两个指针来不断的修改节点的指向

最后我们发现当cur这个指针指向了null的话那么我们的遍历结束了

所以我们的结束条件就是

cur!= null;

思考完遍历结束的条件以后我们应该考虑如何来修改节点的指向

根据这个图我们可以得到大体的思路：cur所在的节点指向prev同时在修改完指向以后向后移动一个节点

然后prev来到了原来cur的位置，同时要想cur向后移动一个节点的话就需要一个临时指针保存cur的后一个节点的位置

所以我们可以写出下面的代码

ListNode tmp = cur.next;
cur.next = prev;
prev = cur;
cur = tmp;

到这里我们的主要的代码就写完了

最后贴上我们的完整代码

    public ListNode reverseList(ListNode head) {
        if(head == null){
            return null;
        }
        ListNode dumyhead = new ListNode(0);
        dumyhead.next = head;
        ListNode prev = dumyhead;
        ListNode cur = prev.next;
        //遍历我们的链表
        while(cur!= null){
            ListNode tmp = cur.next;//用来保存cur后一个节点的位置
            cur.next = prev;
            prev = cur;
            cur = tmp;
        }
        head.next = null;
        return prev;
    }

3两两交换链表的结点

题目：给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

题解：想要解决这道题目首先应该将图给画出来

比如说我们要两两交换前面两个节点，我首先应该定义一个虚拟头节点,这样在结束的时候我才可以返回节点然后编译器找到交换以后的头节点在哪里，这样的话我们的cur每次结束的时候都应该是在应该进行交换的节点的上一个节点处

这道题目的核心就在于遍历链表的过程中如何找到要修改指向的前一个节点并将指向修改

既然提到了遍历那么我们肯定是使用while循环来进行遍历链表的

那么我们循环结束的条件是什么？

通过画图我们可以发现当节点的个数不同的时候，我们结束交换时cur 所在的位置也不同

所以我们的循环终止条件应该写成

cur.next != null && cur.next.next != null

接下来就到了如何交换节点了

既然我们使用了虚拟头节点来完成这道题目，我们交换节点的时候也应该修改虚拟头节点的指向

所以第一步我们将虚拟头节点的指向修改成第二个节点，第二步是将第二个节点指向第一个节点，第三步我们将第一个节点指向第三个节点（这一步是为了下一次交换节点）

那么问题就来了，如何保证虚拟头节点在修改完成指向以后我们的第二步顺利完成以及第二个节点修改完指向以后我们的第三步顺利完成？

那么答案就是定义两个临时指针来记录他们两个所在的位置

有了思路以后我们的代码也就好写了

        while(cur.next != null && cur.next.next != null){
            ListNode tmp1 = cur.next;
            ListNode tmp2 = cur.next.next.next;
            cur.next = cur.next.next;
            cur.next.next = tmp1;
            tmp1.next = tmp2;
            cur = cur.next.next;
        }

最后贴上我们完整代码

    public ListNode swapPairs(ListNode head) {
        if(head == null){
            return null;
        }
        if(head.next == null){
            return head;
        }
        ListNode dumyhead = new ListNode(0);
        ListNode cur = dumyhead;
        cur.next = head;

        while(cur.next != null && cur.next.next != null){
            ListNode tmp1 = cur.next;
            ListNode tmp2 = cur.next.next.next;
            cur.next = cur.next.next;
            cur.next.next = tmp1;
            tmp1.next = tmp2;
            cur = cur.next.next;
        }
        return dumyhead.next;
    }