回顾链表知识:单链表有一个头结点,不存储元素的值,所以P.next才是指链表的第一个元素。
1.合并两个有序链表
法一:递归
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2){
if(l1==null){
return l2;
}
if(l2==null){
return l1;
}
if(l1.val>=l2.val){
l2.next=mergeTwoLists(l1,l2.next);
return l2;
}else{
l1.next=mergeTwoLists(l1.next,l2);
return l1;
}
}
}
2.环形链表
给定一个链表,判断链表中是否有环。
如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,我们使用整数 pos
来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环。注意:pos
不作为参数进行传递,仅仅是为了标识链表的实际情况。
示例:
示例 1:
输入:head = [3,2,0,-4], pos = 1
输出:true
解释:链表中有一个环,其尾部连接到第二个节点。
示例 2:
输入:head = [1,2], pos = 0
输出:true
解释:链表中有一个环,其尾部连接到第一个节点。
示例 3:
输入:head = [1], pos = -1
输出:false
解释:链表中没有环。
法一:循环
思路:使用哈希表来存储节点,如果该节点已经存在于哈希表中,则是循环链表。
代码:
public class Solution {
public boolean hasCycle(ListNode head) {
Set<ListNode> set=new HashSet<ListNode>();
while(head!=null){
if(set.add(head)){
return true;
}
head=head.next;
}
return false; //只有一个节点时返回false
}
}
法二:Floyd判圈算法(也称龟兔赛跑算法,快慢指针算法)
***算法介绍:***也称龟兔赛跑算法,假设龟兔同时进入链表,如果链表有环,则龟兔一定会相遇,否则兔子一定一直在乌龟前面。
思路:兔子结点走两步,龟结点走一步,
public class Solution {
public boolean hasCycle(ListNode head) {
if(head==null||head.next==null){
return false;
}
ListNode fast=head.next;
ListNode slow=head;
while(slow!=fast){
if(fast==null||fast.next==null){
return false;
}
slow=slow.next;
fast=fast.next.next;
}
return true;
}
}
3.相交链表
题目:
给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null 。
思路:
链表1不相交长度为a,链表2不相交长度为b,相交部分链表长度为c,两个指针不会同时到达相交的节点,当遍历完一条链表时就走到另一个链表的头部,则当两个链表的起始节点都走完a+c+b时,就会在相交节点相遇。
三目运算:
x=a>b?a:b
解释:如果a>b,则x=a,否则x=b
代码:
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;
}
}
4.反转链表
给你单链表的头节点 head ,请你反转链表,并返回反转后的链表
法一:递归
(没懂)
class Solution {
public ListNode reverseList(ListNode head) {
if (head == null || head.next == null) {
return head;
}
ListNode newHead = reverseList(head.next);
head.next.next = head;
head.next = null;
return newHead;
}
}
法二:迭代
改变指针指向的方向
1->2->3变为1<-2<-3
(动笔画一下就会了)
class Solution {
public ListNode reverseList(ListNode head) {
ListNode prev=null;
ListNode curr=head;
while(curr!=null){
ListNode next=curr.next;
curr.next=prev;//头结点指向一个新结点
prev=curr;
curr=next;
}
return prev;
}
}
5.回文链表
请判断一个链表是否为回文链表
示例 1:
输入: 1->2
输出: false
示例 2:
输入: 1->2->2->1
输出: true
法一:把链表的值复制到顺序表
思路:
1.把链表的值复制到顺序表(数组)中
2.通过数组比较值
注意区别ArrayList和int[] array
ArrayList:
- size()
- get(i)
- equals()
int[] array:
- length
- array[i]
- ==
class Solution {
public boolean isPalindrome(ListNode head) {
List arrayList=new ArrayList();//这个链表是顺序表,不是数组,函数不同
//将链表中的值复制到数组中
while(head!=null){
arrayList.add(head.val);
head=head.next;
}
int n= arrayList.size()-1;
for(int i=0;i<n;i++){
if(arrayList.get(i).equals(arrayList.get(n-i))){
return true;
}
}
return false;
}
}