链表常见习题OJ(Java实现)

最新推荐文章于 2024-05-05 15:08:18 发布
最新推荐文章于 2024-05-05 15:08:18 发布
阅读量421 收藏 3
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45914985/article/details/104077793
版权

1.删除链表中等于给定值 val 的所有节点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode temp = new ListNode(0);
        temp.next = head;
        ListNode prev = temp;
        ListNode cur = prev.next;
        //cur 指向 prev 的后一个位置
        while (cur != null) {
            if (cur.val == val) {
                prev.next = cur.next;
                cur = cur.next;
            } else {
                prev = cur;
                cur = cur.next;
            }
        }
        return temp.next;
    }

}

2.反转一个单链表

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while (cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
}

3.给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode middleNode(ListNode head) {
        if(head ==  null)  {
            return  null;   
        }
        
        if(head.next ==  null) {
            return  head;
        }
        int steps = getSize(head)/2;
        ListNode cur = head; 
        for( int i = 0; i < steps; i++) {
            cur = cur.next;
        }
        return cur;
    }
    private int getSize (ListNode head) {
        int size = 0;
        for(ListNode cur = head; cur != null; cur = cur.next) {
            size++;       
        }
        return size;
    }
    }

4.输入一个链表，输出该链表中倒数第k个结点。

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        if (head == null || k < 1) {
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        for (int i = 1; i < k;  i++) {
            if(fast.next != null) {
                fast = fast.next;
            } else {
                return null;
            }
        }
        while (fast.next != null){
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}

5.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
                    ListNode prehead = new ListNode(-1);
            ListNode prev = prehead;
            while (l1 != null && l2 != null) {
                if (l1.val <= l2.val) {
                    prev.next = l1;
                    l1 = l1.next;
                }
                else {
                    prev.next = l2;
                    l2 = l2.next;
                }
                prev = prev.next;
            }
            if (l1 == null) {
                prev.next = l2;
            }
            if (l2 == null) {
                prev.next = l1;
            }
            return prehead.next;
        }
    }

6.编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前

import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Partition {
    public ListNode partition(ListNode pHead, int x) {
       if (pHead == null || pHead.next == null) {
                return pHead;
            }
            ListNode posMax = new ListNode(-1);
            ListNode posMin = new ListNode(-1);
            //设置两个头指针指向两个链表的首节点
            ListNode maxHead = posMax;
            ListNode minHead = posMin;
            ListNode curNode = pHead;
            while (curNode != null) {
                if (curNode.val < x) {
                    posMin.next = curNode;
                    posMin = posMin.next;
                } else {
                    posMax.next = curNode;
                    posMax = posMax.next;
                }
                curNode = curNode.next;
            }
            //posMin 链表的最后一个节点指向 posMax 链表的第一个节点
            posMin.next = maxHead.next;
            //posMax 链表的最后一个节点指向空指针
            posMax.next = null;
            return minHead.next;
    }
}

7.在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead)
    {
                if (pHead == null || pHead.next == null) {
                    return pHead;
                }
                ListNode head = new ListNode(-1);
                head.next = pHead;
                ListNode pre = head;
                ListNode last = head.next;
                while (last != null) {
                    if (last.next != null && last.val == last.next.val) {
                        while (last.next != null && last.val == last.next.val) {
                            last = last.next;
                        }
                        pre.next = last.next;
                        last = last.next;
                    } else {
                        pre = pre.next;
                        last = last.next;
                    }
                }
                return head.next;
        }
}

8.链表的回文结构

import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class PalindromeList {
    public boolean chkPalindrome(ListNode A) {
        // write code here
        //先找到中间节点,然后把后面的链表逆置,和前面的链表比较
       ListNode fast = A;
       ListNode slow = A;
       while (fast != null && fast.next != null) {
           fast = fast.next.next;
           slow = slow.next;
       }
       ListNode mid = slow.next;//中间节点的下一个节点
        slow.next = null;//断连
        ListNode cur = null;
        ListNode prev = null;//标记逆置后的表头
        //逆置
        while (mid != null) {
            prev = mid.next;
            mid.next = cur;
            cur = mid;
            mid = prev;
        }
        //依次比较两个链表
        while (A != null && cur != null) {
            if (A.val != cur.val) {
                return false;
            }
              A = A.next;
            cur = cur.next;
        }
        return true;
    }
}

9.输入两个链表，找出它们的第一个公共结点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
            if (headA == null || headB == null) {
                return null;
            }
            ListNode pA = headA;
            ListNode pB = headB;
            while (pA != pB) {
                pA = pA == null ? headB : pA.next;
                pB = pB == null ? headA : pB.next;
            }
            return pA;
        }
    }

10.给定一个链表，判断链表中是否有环

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
                    if (head == null || head.next == null) {
                return false;
            }
            ListNode slow = head;
            ListNode fast = head.next;
            while (slow != fast) {
                if (fast == null || fast.next == null) {
                    return false;
                }
                slow = slow.next;
                fast = fast.next.next;
            }
            return true;
    }
}

11.给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
            ListNode slow = head;
            ListNode fast = head;
            while (true) {
                if (fast == null || fast.next == null) {
                    return null;
                }
                slow = slow.next;
                fast = fast.next.next;
                if (fast == slow) {
                    break;
                }
            }
            fast = head;
            while (slow != fast) {
                slow = slow.next;
                fast = fast.next;
            }
            return fast;
    }
}

链表问题还是比较复杂,难以理解,需要借助画图才可以有思路,得多练,多敲!

JIAYU.
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
链表常见题型（java版）
sywyg
09-18 7万+
链表常见题型： 1.找到单链表的倒数第k个节点。 2.删除单链表中的某个结点（O(1)）。 3.反转链表。 4.两个链表的第一个公共结点。 5.有环链表返回环路的开头节点(及判断是否有环)。 6.合并两个排序的链表。 7.删除链表中重复的结点。
常见的链表问题（java）
LiuXiaoXueer的博客
07-31 114
目录定义链表结构打印链表的值反转单向链表（重要)有环链表相交链表 定义链表结构 public static class Node{ public int value; public Node next; public Node(int data){ value = data; } } 打印链表的值 public static void printLinedList(Node head){ System.out.print("Linked List:"); while(head != n
每日一题:Java实现单向链表的反转
qq_64580912的博客
10-25 1529
实现单向链表的反转其实就是将链表的最后一个结点放在第一位,将倒数第二个节点放在第二位,以此类推.我们学过链表的的两种插入节点的方法,一种是头插法,一种是尾插法,刚好这两种方式插入的时候结点的顺序正好是相反的,相当如将头插法按尾插法的方式插入,正好就是可以实现链表的插入。
单链表的反转java实现
weixin_41905047的博客
02-19 708
给定一个单链表的头结点pHead，长度为n，反转该链表后，返回新链表的表头。
在线OJ——链表经典例题详解
最新发布
hu_ju_hong的博客
05-05 980
在线OJ，链表经典例题详细讲解。看懂，会写，链表其实没这么难！！
Java实现单链表的反转
小马快跑的博客
02-22 556
文章目录方式一：直接反转方式二：递归反转 方式一：直接反转 对链表的某个节点Node执行指针反转时，同时需要知道当前Node的前驱Node、后继Node。 public class Node { public Node next; //后置节点 public String content; //节点内容 public Node(String content, Node next) { this.content = content; this.n
【Java】利用双指针解决十道经典的链表面试题（图文详解）
Superkom666的博客
09-21 915
有以下几道经典的题目 1.删除链表中等于给定值 val 的所有节点 2.反转一个单链表 3.给定一个带有头结点 head 的非空单链表，返回链表的中间结点 4.输入一个链表，输出该链表中倒数第k个结点 5.将两个有序链表合并为一个新的有序链表并返回 6.以给定值x为基准将链表分割成两部分 7.链表的回文结构 8.输入两个链表，找出它们的第一个公共结点 9.给定一个链表，判断链表中是否有环 10.给定一个链表，返回链表开始入环的第一节点
java单链表反转
花生日记
05-04 1509
这两种方法都可以进行链表头节点定位操作，下面我们就来分别了解一下这两种方法： 我们来看一下上面给出的代码： 上面给出的代码只给出了一种方式来确定一个链表结构是有序还是无序的，如果不知道该如何判断的话，那么我们就可以通过上面给出的代码进行判断；在上面的代码中，我们首先定义了一个指针变量x来存储哈希表中的1和3,然后我们在哈希表中增加了一个变量 xmode来存储哈希表中的元素。下面是使用哈希表来反转 double [3]（）的代码： 这个代码中，我们首先在哈希表中建立了一个数组，然后我们创建了一个哈希表对象。
链表的原理及java实现代码示例
08-28
"链表的原理及Java实现代码示例" 链表是一种基本的数据结构，它的实现原理不同于数组。链表的优点是插入和删除操作效率高，而缺点是循环遍历时效率不高。Java中使用的LinkedList的实现原理就是链表。 单向链表的...
Java算法练习-环形链表插值练习题
10-01
java学习
Java实现双向链表(两个版本)
09-02
主要介绍了Java实现双向链表(两个版本)的相关资料,需要的朋友可以参考下
去除链表重复元素-Java 实现
04-26
附件是Java 实现的去除链表重复元素。在Java中，去除单链表中的重复元素可以通过使用哈希集合（HashSet）来实现，该集合用于存储已经遍历过的元素。在遍历链表的过程中，我们将每个元素与集合中的元素进行比较，如果...
Java算法练习-链表的分化练习题
10-07
java
【算法练习】4种反转链表的方法（Java实现）
软件工程探索之旅
08-17 3803
几种链表反转方法的主要区别在于迭代法和递归法是在原链表上直接反转,无需额外空间;而头插法和栈辅助需要 O(N) 的额外空间。一般迭代法代码最简洁,递归法需要处理终止条件,但思路清晰。
单链表反转（Java实现）
regens的博客
03-21 1563
链表反转
反转链表的Java方式实现
qq_50721879的博客
11-28 991
反转链表(reverse-linked)的Java方式实现
Java 算法篇-深入了解单链表的反转（实现：用 5 种方式来具体实现）
小扳手
11-13 4267
单链表的反转是指将链表中的节点顺序逆转，即原先的链表尾部变成了头部，头部变成了尾部。比如，[1,2,3,4,5,6,7] 将这个链表的值反转得到的结果为：[7,6,5,4,3,2,1]，需要注意的是，可以用值打印出来会更好观察链表反转后的结果。 具体的创建思路：首先要把节点进行封装成单独的类，该类中的成员包括：int value 存放值，Node next 引用下一个节点。由于该节点类为链表中的一个组成部分，因此，将该类设为静态内部类，外部类的成员为哨兵节点。
Java实现链表反转的两种思路
Cavewang的博客
10-06 1031
Java实现链表反转的两种思路
Java 简单实现单向链表反转
龚小帅的博客
09-13 513
第二个参数虽然是个 Runnable，但是采用的还是同步方法调用，直接自己调用 run() 方法，所以这段逻辑执行还是在同一个线程执行，并没有开启异步线程。
把一个链表转换为数组，Java实现
06-02
可以使用Java中的ArrayList来实现链表到数组的转换，具体代码如下： ``` // 定义链表节点 class ListNode { int val; ListNode next; ListNode(int val) { this.val = val; } } // 将链表转换为数组 public int[] listToArray(ListNode head) { List<Integer> list = new ArrayList<>(); while (head != null) { list.add(head.val); head = head.next; } int[] arr = new int[list.size()]; for (int i = 0; i < list.size(); i++) { arr[i] = list.get(i); } return arr; } ``` 首先定义链表节点，然后定义一个方法将链表转换为数组。在方法中，我们使用ArrayList来存储链表节点的值，然后将ArrayList转换为int数组并返回。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值