链表（1）—简单难度

简单难度——链表（java实现）

反转链表

题目描述
输入一个链表，反转链表后，输出新链表的表头。

示例1
输入：{1,2,3}
返回值：{3,2,1}

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

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        
        ListNode pre = null;
       
        ListNode nex = head;
       
        while(head != null){
            nex = head.next;
            head.next = pre;
            pre = head;
            head = nex;
        }
        
        // 1 2 3 4 5 6
       return pre;
    }
}

判断链表中是否有环

题目描述
判断给定的链表中是否有环。如果有环则返回true，否则返回false。
你能给出空间复杂度O(1)的解法么？

/**
 * 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) {
       
      ListNode fast = head;
        ListNode slow = head;
        
        while(fast != null && fast.next != null){    //防空指针异常
            fast = fast.next.next;            //若fast==null，根据逻辑运算符的短路特性，不会在计算fast.next
            slow = slow.next;
            if(fast == slow)
                return true;
        }
        return false;
    }
   
}

合并有序链表

题目描述
将两个有序的链表合并为一个新链表，要求新的链表是通过拼接两个链表的节点来生成的，且合并后新链表依然有序。

示例1
输入：{1},{2}
返回值：{1,2}

示例2
输入：{2},{1}
返回值：{1,2}

import java.util.*;

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

public class Solution {
    /**
     * 
     * @param l1 ListNode类 
     * @param l2 ListNode类 
     * @return ListNode类
     */
    public ListNode mergeTwoLists (ListNode l1, ListNode l2) {
        // write code here
        //一般链表的第一个节点都需要特殊处理，在第一个节点前增加一个虚拟的头结点，将第一个节点一般化，最后输出
        //这个虚拟节点的下一个节点
        ListNode l = new ListNode(0);
        ListNode tmp = l;
        if(l1 == null) return l2;
        if(l2 == null) return l1;
        
        while(l1 != null && l2 != null){
            if(l1.val <= l2.val){
                tmp.next = l1;
                l1 = l1.next;
            }
            else{
                tmp.next = l2;
                l2 = l2.next;
            }
            
            tmp = tmp.next;
        }
        
        if(l1 != null)
            tmp.next = l1;
        else
            tmp.next = l2;
        
        return l.next;
    }
}

两个链表的第一个公共节点

题目描述
输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）

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

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        //双指针
        if(pHead1 == null || pHead2 == null) return null;
        ListNode p1 = pHead1;
        ListNode p2 = pHead2;
          //当两个链表拥有公共节点，公共节点后都相同,使得两链表具有相同的长度a+b
        
        while(p1 != p2){
            p1 = p1.next;
            p2 = p2.next;
            if(p1 != p2){
                if(p1 == null) p1 = pHead2;
                if(p2 == null) p2 = pHead1;
            }
        }
        return p1;
    }
}

链表中倒数第k个节点

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

示例1
输入：1,{1,2,3,4,5}
返回值：{5}

    public ListNode FindKthToTail(ListNode head, int k) {
        ListNode p, q;
        for (p = q = head; p != null; p = p.next, k--)
            if (k <= 0)
                q = q.next;
        return k <= 0 ? q : null;
    }

if(head == null || k < 1)
            return null;
        ListNode fast = head;
        ListNode slow = head;
        while(k > 0) {
            if(fast == null)
                return null;
            fast = fast.next;
            k--;
        }
        while(fast!= null) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow;

删除有序链表中重复的元素

题目描述
删除给出链表中的重复元素（链表中元素从小到大有序），使链表中的所有元素都只出现一次
例如：
给出的链表为1→1→2,返回1→2.
给出的链表为1→1→2→3→3,返回1→2→3.

public ListNode deleteDuplicates (ListNode head) {
        // write code here
        if(head == null)
            return head;
       ListNode res = head;
        
        while(res.next != null){
            if(res.val == res.next.val)
                res.next = res.next.next;    //该链表删除res.next节点
            else
                res = res.next;    //继续遍历
        }
        
        return head;
    }