链表

一.

题目描述

给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

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

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    //找到一快一慢指针相遇处的结点，相遇的结点一定是在环中
    public static ListNode meetingNode(ListNode head) {
       if(head==null||head.next==null||head.next.next==null)return null;
        ListNode fast=head.next.next;
        ListNode slow=head.next;
        //先判断有没有环
        while(fast!=slow){
 
            if(fast.next!=null&& fast.next.next!=null){
 
                fast=fast.next.next;
 
                slow=slow.next;
 
            }else{
                //没有环,返回
                return null;
            }
        }
        return fast;
    }
    public ListNode EntryNodeOfLoop(ListNode pHead) {
        ListNode meetingNode=meetingNode(pHead);//得到快慢指针相遇的结点，此结点一定在链表的环中
        if(meetingNode==null)
            return null;
        
        int count=1;
        ListNode p=meetingNode;//从相遇结点开始计算环中结点数
         while(p.next!=meetingNode){
             p=p.next;
             count++;
         }
        
        ListNode p1=pHead;
        for(int i=0;i<count;i++){//快指针先走环中结点数
            p1=p1.next;
        }
        
        ListNode p2=pHead;
        while(p1!=p2){//快慢指针一起走，相遇的结点即为环的入口结点
            p1=p1.next;
            p2=p2.next;
        }
        
        return p1;
    }
}

二.

题目描述

如何判断两个链表是否相交

借用大佬的详解

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    if (headA == null || headB == null) return null;
    ListNode pA = headA, pB = headB;
    while (pA != pB) {
        pA = pA == null ? headB : pA.next;
        pB = pB == null ? headA : pB.next;
    }
    return pA;
}

三.

题目描述

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

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

四.

题目描述

循环链表插入元素

关于单向循环链表的操作

五.

题目描述

输入一个链表，反转链表后，输出新链表的表头。

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

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        if(head==null)
            return null;
        ListNode pre=null;
        ListNode next=null;
        while(head!=null){
              next=head.next;
              head.next=pre;
              pre=head;
              head=next;  
        }
        return pre;
    }
}

六.

题目描述

输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList list=new ArrayList();
        while(listNode!=null){
            list.add(0,listNode.val);
            listNode=listNode.next;
        }
        return list;
    }
}

七.

题目描述

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

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

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        if(list1==null){
            return list2;
        }
         if(list2==null){
            return list1;
        }
        //得到两个链表中值较小的头结点，并把它连接到已经合并的链表之后
        if(list1.val<list2.val){
            list1.next=Merge(list1.next,list2);//如果链表1较小，则选取链表1，指针移动到链表1的下一个元素，链表2的指针不动
           return list1;
        }else{
              list2.next=Merge(list2.next,list1);
            return list2;
        }
    }
}