链表专题（代码随想录day3、4）

链表专题（代码随想录day3、4）

1.链表基础概念

什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。

链表的入口节点称为链表的头结点也就是head。

定义链表

class ListNode {
    int val;
    ListNode next;

    public ListNode() {
    }

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

    public ListNode(int val) {
        this.val = val;
    }
}

leetCode题

203.移除链表元素

两种做法：一种虚拟头节点

链表移除某一个节点的时候，你需要知道前一个节点，让前一个节点指向下下个节点就是删除了。

public ListNode removeElements(ListNode head, int val) {
        //虚拟头节点
        ListNode dumyHead = new ListNode();
        dumyHead.next = head;

        ListNode cur = dumyHead;
        //因为存在第一个头节点就可能是要被删除的元素.所以需要知道上一个节点
        while (cur.next != null) {
            if (cur.next.val == val) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
		//返回虚拟节点的下一个
        return dumyHead.next;
    }

public ListNode removeElements2(ListNode head, int val) {
        //普通的移除方法,需要考虑是否第一个节点是不是要移除的元素
        while (head != null && head.val == val) {
            head = head.next;
        }
        //现在head经过上面的循环,肯定不是要移除的元素了,建一个临时指针,判断head后面的节点是否是要移除的元素
        ListNode cur = head;
        while (cur != null) {
            if (cur.next != null && cur.next.val == val) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
        return head;
    }

时间复杂度: O(n)
空间复杂度: O(1)

707.设计链表

实现五个方法，其实只用实现三个方法，实现addAtIndex(index,val)的时候考虑下实现addAtHead(val)和addAtTail(val)

无论是删除还是插入都需要获取他的前一个节点

1. [-- 后续补充使用双链表实现 ]

class MyLinkedList {

    //size用来存储链表元素的个数
    int size;
    //虚拟头节点
    ListNode dummyHead;


    //初始化
    public MyLinkedList() {
        size = 0;
        dummyHead = new ListNode(0);
    }

    //获取链表中第 index 个节点的值。如果索引无效，则返回-1
    public int get(int index) {
        //参数校验
        if (index < 0 || index >= size) {
            return -1;
        }

        ListNode cur = dummyHead.next;
         获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
        for (int i = 0; i < index; i++) {
            cur = cur.next;
        }
        return cur.val;

    }

    //在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点
    public void addAtHead(int val) {
        addAtIndex(0, val);
    }

    //将值为 val 的节点追加到链表的最后一个元素。
    public void addAtTail(int val) {
        addAtIndex(size, val);
    }

    //在链表中的第 index 个节点之前添加值为 val  的节点。
    // 如果 index 等于链表的长度，则该节点将附加到链表的末尾。
    // 如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点
    public void addAtIndex(int index, int val) {

        //index参数判断
        if (index > size) {
            return;
        }

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

        //找到要插入节点的前一个节点
        ListNode pre = dummyHead;
        for (int i = 0; i < index; i++) {
            pre = pre.next;
        }

        //准备插入节点,先构造要插入的节点
        ListNode toAddNode = new ListNode(val);
        //让要插入的节点下一个指针指向pre.next
        toAddNode.next = pre.next;
        //pre指向toAddNode节点
        pre.next = toAddNode;

        size++;
    }

    //如果索引 index 有效，则删除链表中的第 index 个节点。
    public void deleteAtIndex(int index) {
        //参数校验
        if (index < 0 || index >= size) {
            return;
        }

        ListNode pre = dummyHead;
        for (int i = 0; i < index; i++) {
            pre = pre.next;
        }
        pre.next = pre.next.next;


        size--;
    }
}

206.反转链表

两种解法：理解双指针后模拟写递归

 public ListNode reverseList(ListNode head) {

        ListNode cur = head;

        ListNode pre = null;


        while (cur != null) {
            ListNode temp = cur.next;
            //改变方向
            cur.next = pre;
            //然后两个指针都往后移动
            pre = cur;
            cur = temp;
        }
        return pre;
    }

时间复杂度: O(n)
空间复杂度: O(1)

    //递归写法
    public ListNode reverseList2(ListNode head) {

        return reverse(null, head);
    }

    private ListNode reverse(ListNode pre, ListNode cur) {
        if (cur == null) {
            return pre;
        }
        ListNode temp = cur.next;  //先保存下一个节点
        cur.next = pre;  //反转

        //更新pre和cur的位置
        //pre = cur  和  cur = temp
        return reverse(cur, temp);
    }

时间复杂度: O(n), 要递归处理链表的每个节点
空间复杂度: O(n), 递归调用了 n 层栈空间

24. 两两交换链表中的节点

//24. 两两交换链表中的节点
    //给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
    //需要知道.假如有1,2,3,cur在1节点的时候你才能操作2,3

    public ListNode swapPairs(ListNode head) {

        //虚拟一个头结点
        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;

        ListNode cur = dummyNode;
        //虚拟头结点的下一个和下下一个节点不为空的时候再交换，奇数的话是不进入循环的
        while (cur.next != null && cur.next.next != null) {

            //值进行交换，先让虚拟头结点指向第二个节点，再让第一个节点指向第三个节点，再让第2个节点指向第一个节点
            //需要临时保存俩节点，第一个节点，还有

            //临时节点，保存第三个节点
            ListNode third = cur.next.next.next;
            ;
            //临时节点，保存一个节点
            ListNode first = cur.next;
            //临时节点，保存第二个节点
            ListNode second = cur.next.next;
            ;

            //交换
            cur.next = second;
            second.next = first;
            first.next = third;

            //cur移动到下一个位置，(就是第二个节点的位置)进行后面的交换
            cur = cur.next.next;
        }
        return dummyNode.next;
    }

时间复杂度：O(n)
空间复杂度：O(1)

19.删除链表的倒数第N个节点

删除倒数第n个节点，等于我们需要知道倒数第n-1的位置
为了测出n-1，定义快慢指针（虚拟头节点），让快慢指针保持距离n，然后一起遍历，快指针到最后一个节点的时候，慢指针就在n-1上

 public ListNode removeNthFromEnd(ListNode head, int n) {
        //定义虚拟头节点,定义快慢指针,快指针先走n,然后快慢指针一起走,
        // 最后慢指针就走到了倒数n-1的地方了,使用双指针保持距离得到n-1
        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;

        ListNode firstNode = dummyNode;
        ListNode slowNode = dummyNode;
        //快指针先走n步
        while (n > 0 && firstNode != null) {
            firstNode = firstNode.next;
            n--;
        }

        //还要判断firstNode.next是否为空,
        //因为我们想让first停在最后一个节点上,slow停在倒数n-1的位置
        //此时slowNode是在倒数第n-1个节点的位置上
        while (firstNode != null) {
            slowNode = slowNode.next;
            firstNode = firstNode.next;
        }
        if (slowNode.next != null) {
            slowNode.next = slowNode.next.next;

        }

        return dummyNode.next;
    }

时间复杂度: O(n)
空间复杂度: O(1)

面试题 02.07. 链表相交

 public ListNode getIntersectionNode(ListNode headA, ListNode headB) {

        //首先需要获取哪个链表长
        //然后让长的先把他俩的长度差走一下,然后两个链表就等长,再while遍历它们
        int lengthA = getLength(headA);
        int lengthB = getLength(headB);

        ListNode curA= headA;
        ListNode curB= headB;
        //判断a和b谁长,谁长谁走
        if (lengthA > lengthB) {
            int longer = lengthA -lengthB;
            while(longer > 0){
                curA = curA.next;
                longer--;
            }
        } else if (lengthA < lengthB) {
            int longer = lengthB -lengthA;
            while(longer > 0){
                curB = curB.next;
                longer--;
            }
        }

        while(curA != null && curA != null){
            if(curA == curB){
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }

    private int getLength(ListNode head) {
        if (head == null) {
            return 0;
        }
        int length = 0;
        ListNode cur = head;
        while (cur != null) {
            cur = cur.next;
            length++;
        }
        return length;
    }

时间复杂度：O(n + m)
空间复杂度：O(1)

142.环形链表II

 public ListNode detectCycle(ListNode head) {
        //这个是需要简单推理一下
        //首先,我们得判断这个链表是否有环,判断有没有环比较简单,定义俩指针,一快一慢,快的走两步,慢的走一步
        //如果相遇肯定是有环,如果是快指针为null了,那肯定是无环
        //接下来就是进行一个简单的证明题
        //假设链表长a,环长b, 假如快慢指针相遇在环的x点, 那么快指针走了(n代表了圈数)a+nb+x;慢指针走了a+x
        //假如第一圈相遇,由于快指针走的是慢指针的2倍, 2(a+x) = a+b+x;  a=b-x
        //所以慢指针在x位置上时,定义指针在起点,同时走,由于a=b-x,相遇的点即是要找的点

        ListNode first = head;
        ListNode slow = head;

        while(first != null && first.next != null){
            first = first.next.next;
            slow = slow.next;

            //如果相遇就break
            if(slow == first){
                break;
            }

        }

        //没有环
        if(first == null || first.next == null){
            return null;
        }

        //有环
        ListNode newHead = head;

        while(newHead != slow){
            newHead = newHead.next;
            slow = slow.next;
        }

        return newHead;
    }

时间复杂度: O(n)，快慢指针相遇前，指针走的次数小于链表长度，快慢指针相遇后，两个index指针走的次数也小于链表长度，总体为走的次数小于 2n
空间复杂度: O(1)

总结：链表的题多采用虚拟头节点、双指针的思想。