链表OJ题---Java实现

前言

大家好!!!我是Java猿~

因为疫情原因被封宿舍,这样也好,不乱跑,不给社会添乱。

因为在宿舍无事可干,但是也不能落下学习,所以刷几道链表的OJ题来巩固之前所学的,这里分享一下解题方法,希望大家相互学习,欢迎回访哟!!!

新的一年,祝大家虎年快乐!!!

最后也希望疫情快点结束,加油陕西!加油长安!!!

目录

LeetCode 203 移除链表元素

LeetCode 876 链表的中间节点 

剑指Offer 22 链表中倒数第k个节点

LeetCode 21 合并两个有序链表

Leetcode 面试题 02.04. 分割链表

LeetCode 234 回文链表

LeetCode 160 相交链表


LeetCode 203 移除链表元素

题目链接:移除链表元素

题目:给一个链表和一个整数,删除链表中所有值为该整数的节点,并将删除后的链表返回。

示例:

链表OJ题---Java实现_第1张图片

题目解析:删除链表中所有节点元素等于一个整数的节点,返回删除后的链表的头节点。

思路:遍历链表与给定值比较,如果节点的值与给定值相等就删除该节点,链表节点的删除需要标记删除节点的前一个节点,具体步骤如下: 

1. 首先进行链表判空,如果链表为空,则将空链表返回就行

2. 给两个标记,cur标记依次遍历的节点,pre标记cur的前一个结点

3. 判断要删除的结点是否为头节点,如果为头节点就要更新头节点,因为题目要求返回删除后链表的头节点,判断头节点的方法是pre为null

4. 如果不是头节点就正常删除即可 

‍参考代码:

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        //判空
        if(head == null){
            return head;
        }
        ListNode cur = head;
        ListNode pre = null;
        while(cur != null){
            if(cur.val == val){
                if(pre == null){   //删除节点为头节点
                    head = cur.next; //更新头节点
                    cur = head;
                }else{
                    pre.next = cur.next;
                    cur = pre.next;
                }
            }else{       //如果当前节点不是要删除的节点,依次遍历
                pre = cur;
                cur = cur.next;
            }
        }
        return head;
    }
}

LeetCode 876 链表的中间节点 

题目链接:链表的中间节点 

题目:给一个头节点为head的非空单链表,返回链表的中间节点,如果中间节点有两个,则返回第二个中间节点。

题目解析:如果链表有奇数个节点,则返回中间的节点,如果有链表有偶数个节点,则返回中间两个靠后的节点,画图说明:

链表OJ题---Java实现_第2张图片

思路:快慢指针法:一个快指针fast,一个慢指针slow,两个指针同时依次遍历链表当快指针走到末尾的时候,慢指针刚好走到中间位置,画图说明:

链表OJ题---Java实现_第3张图片

具体步骤:

1. fast快指针与slow慢指针依次遍历

2. 遍历的条件:fast != null && fast.next != null

3. 最后当遍历条件不满足的时候,返回slow

‍参考代码:

class Solution {
    public ListNode middleNode(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }
}

剑指Offer 22 链表中倒数第k个节点

题目链接:链表中倒数第k个节点 

题目:输入一个链表,输出该链表中倒数第k个节点。为了符合大多数人的习惯,本题从1开始计数,即链表的尾节点是倒数第1个节点。

示例:

链表OJ题---Java实现_第4张图片

思路:这一提供一个巧妙方法:给两个指针fast,slow,fast先走,slow后走,两个指针都是从链表头开始遍历,当fast走完k个节点后,slow在开始从头部开始走,而fast继续从当前节点往后走,当fast走到null的时候,slow对应的节点即为要返回的节点。具体步骤如下:

1. fast开始走完k个节点

2. slow再与fast同时开始往后每次走一步

3. 当fast走到链表末尾,slow即为要返回节点

‍参考代码: 

class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode fast = head;
        ListNode slow = head;
        while(k > 0){
            fast = fast.next;
            k--;
        }
        if(fast == null){
            return head;
        }
        while(fast != null){
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}

LeetCode 21 合并两个有序链表

题目链接:合并两个有序链表 

题目:将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。示例:

链表OJ题---Java实现_第5张图片

题目解析:给两个升序链表,将这两个升序链表合并为一个升序链表 

思路:对于本题,我们可以创建一个新的链表,让两个链表的元素依次比较,哪个元素小,就链接在新链表中,依次循环,当某一个链表的节点都已经链接新的链表中,就把另一个链表剩余的节点直接链接在新链表中。具体步骤如下:

1. 先new一个新的链表

2. 将两个链表的元素依次遍历比较

3. 将元素小的节点插入新的链表中,继续比较

4. 当有一条链表的元素全部插入新的链表中,就把另一条链表剩余的部分链接到新的链表的末尾

‍参考代码:

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode list3 = new ListNode(0);
        ListNode cur = list3;
        while(list1 != null && list2 != null){
            if(list1.val < list2.val){
                cur.next = list1;
                cur = cur.next;
                list1 = list1.next;
            }else{
                cur.next = list2;
                cur = cur.next;
                list2 = list2.next;
            }   
        }
        if(list1 != null){
            cur.next = list1;
        }     
        if(list2 != null){
            cur.next = list2;
        }
        return list3.next;
    }
}

Leetcode 面试题 02.04. 分割链表

题目链接:分割链表

题目:给你一个链表的头节点head和一个特定值x,请你对链表进行分隔,使得所有小于x 的节点都出现在大于等于x 的节点之前。示例:

链表OJ题---Java实现_第6张图片

题目解析:给一条链表和一个特定的值,将链表中的值与给定的值比较,将小于给定值的节点排在链表的前面,其余的就按照开始的顺序排在后面。

思路:我们可以创建两条链表,将小于给定值的节点插入第一条链表中,将剩余节点插入第二条链表中,最后将这两条链表进行链接即可。具体步骤如下:

1. 对链表进行判空,如果链表为空,将空链表返回即可

2. new两条新的链表

3. 遍历链表,将小于给定值的节点插入第一条链表,剩余节点插入第二条链表

4. 链接两条链表,第一条链表的尾链接第二条链表的头

5. 第二条链表的尾部指向空即可

‍参考代码:

class Solution {
    public ListNode partition(ListNode head, int x) {
        if(head == null){
            return head;
        }
        ListNode headL = new ListNode(0);
        ListNode curL = headL;
        ListNode headR = new ListNode(0);
        ListNode curR = headR;
        ListNode cur = head;
        while(cur != null){
            if(cur.val < x){
                curL.next = cur;
                curL = cur;
                cur = cur.next;
            }else{
                curR.next = cur;
                curR = cur;
                cur = cur.next;
            }
        }
        curL.next = headR.next;
        curR.next = null;
        return headL.next;
    }
}

LeetCode 234 回文链表

题目链接:回文链表 

题目:给一条链表,如果链表满足回文结构返回true,否则返回false

题目解析:所谓回文结构就是正着与反着是一样的比如:12321,123321,这样的结构就是回文结构。

思路1:我们可以将链表的结点元素保存在数组中,然后判断这个数组是否回文,具体步骤如下:

1. new一个ArrayList,用于保存链表结点元素

2. 遍历链表,将链表结点元素保存在List中

3. 从List头部拿一个元素,尾部拿一个元素进行比较,如果相同进行下一轮比较,如果不相同返回false

4. 当链表遍历完后,都相同的话返回true

‍参考代码:

class Solution {
    public boolean isPalindrome(ListNode head) {
        //将值复制到数组中,判断数组是否回文
        List list = new ArrayList<>();
        ListNode cur = head;
        while(cur != null){
            list.add(cur.val);
            cur = cur.next;
        }
        int left = 0;
        int right = list.size()-1;
        while(left < right){
            if(list.get(left) == list.get(right)){
                left++;
                right--;
            }else{
                return false;
            }
        }
        return true;
    }
}

思路2:我们可以将链表进行分割,然后将后半部分链表进行逆置,再将逆置后的部分与前半部分依次比较,如果结点的值都相同则为回文,否则不是回文结构。具体步骤如下:
1. 分割链表,上一题讲过,可以参考上一题

2. 逆置链表,这个前面也讲过,附上链接,不会的可以点击链接学习,LeetCode206---反转链表(Java实现,有图解)_轻盈照溪水的博客-CSDN博客 

3. 进行比较

注意:这种思路涉及到链表的分割与逆置,故当作重点题进行学习

‍参考代码:

class Solution {
    public ListNode getMid(ListNode head){
        ListNode fast = head;
        ListNode slow = head;
        ListNode pre = null;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            pre = slow;
            slow = slow.next;
        }
        if(fast != null){
            return slow;
        }else{
            return pre;
        }
    }
    public ListNode reverse(ListNode head){
        ListNode cur = head;
        ListNode next = null;
        ListNode pre = null;
        while(cur != null){
            next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
    public boolean isPalindrome(ListNode head) {
        ListNode mid = getMid(head);
        ListNode B = mid.next;
        B = reverse(B);
        ListNode curB = B;
        ListNode curA = head;
        while(curB != null){
            if(curA.val != curB.val){
                return false;
            }
            curA = curA.next;
            curB = curB.next; 
        }
        return true;
    }
}

LeetCode 160 相交链表

题目链接:相交链表 

题目:给两条链表的头节点,返回两条链表的起始节点,如果不相交,返回null

题目解析:有两条链表,链表可能会相交,如果相交返回相交的起始节点,如果不相交返回null

思路:首先进行判断链表是否相交,判断依据:如果两条链表相交,则两条链表的尾节点一定是相同的。在相交前,有可能两条链表一样长,也有可能不一样长,对应如下情形:

链表OJ题---Java实现_第7张图片

对于左边的这种情形:直接遍历求第一个相等的节点即可

对于右边的这种情形:可以先统计两条链表的长度,哪条长,就先走超出的长度,走完后,两条链表在同时遍历,这样就形成了左边的情形,即很快可以找到相交节点

具体步骤:

1. 进行判空,如果有一条链表为空,肯定不相交,直接返回null

2. 统计两条链表节点的个数,将两条链表对应的节点个数做差

3. 统计完个数,两条链表都到末尾,判断末尾节点是否相同,若不同说明不存在交点,返回null

4.  如果差值大于0,说明第一条链表长,先走差值个长度

5.  如果差值小于0,说明第二条链表长,先走差值个长度

6. 两条链表再依次遍历,找相同的节点然后返回 

‍参考代码:

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null){
            return null;
        }
        ListNode curA = headA;
        int sizeA = 1;
        while(curA != null){
            sizeA++;
            curA = curA.next;
        }
        ListNode curB = headB;
        int sizeB = 1;
        while(curB != null){
            sizeB++;
            curB = curB.next;
        } 
        if(curA != curB){
            return null;
        }
        curA = headA;
        curB = headB;
        int alm = sizeA - sizeB;
        if(alm >= 0){
            while(alm > 0){
                curA = curA.next;
                alm--;
            }
        }else{
            while(alm < 0){
                curB = curB.next;
                alm++;
            }
        }
        while(curA != curB){
            curA = curA.next;
            curB = curB.next;
        }  
        return curA;  
    }
}

你可能感兴趣的:(刷题,链表,java,算法,数据结构---链表,链表面试题)