Leetcode面T2(1-8)链表

Q2.1 移除重复节点

编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。

示例1:

 输入：[1, 2, 3, 3, 2, 1]
 输出：[1, 2, 3]
示例2:

 输入：[1, 1, 1, 1, 2]
 输出：[1, 2]

链表节点定义

public class ListNode {
    //节点存储的数据
    int val;
    
    //节点的后继节点
    ListNode next;

    //构造方法，生成一个节点时要存入一个数据
    public ListNode(int val) {
        this.val = val;
    }
}

方法实现

import java.util.HashSet;
import java.util.Set;

class Solution {
    public ListNode removeDuplicateNodes(ListNode head) {
        //pre指向当前节点的前驱
        ListNode pre = null;
        ListNode p = head;
        Set set = new HashSet<>();

        //遍历节点
        while (p != null) {
            //如果哈希表中已存在这个元素则删除
            if (set.contains(p.val)) {
                //删除，删除后前驱节点不需要往后移
                pre.next = p.next;
            } else {
                //如果哈希表中不存在这个元素则添加进来
                set.add(p.val);
                //未删除，前驱节点后移
                pre = p;
            }
            //无论是否删除都让p指向下一个待检测的节点
            p = p.next;
        }
        return head;
    }

    public static void main(String[] args) {
        //定义一个测试样例
        int arr[] = {1, 2, 3, 3, 2, 1};

        //将数组元素依次存入链表
        ListNode head = new ListNode(1);
        int i = 1;
        ListNode p1 = head;
        while (i < arr.length) {
            p1.next = new ListNode(arr[i]);
            p1 = p1.next;
            ++i;
        }

        //调用方法测试
        new Solution().removeDuplicateNodes(head);

        //输出样例的预期结果
        ListNode p2 = head;
        while (p2 != null) {
            System.out.print(p2.val + (p2.next == null ? "" : " "));
            p2 = p2.next;
        }
    }
}

对于进阶问题：如果不得使用临时缓冲区，该怎么解决？一种简单的方法是，我们在给定的链表上使用两重循环，其中第一重循环从链表的头节点开始，枚举一个保留的节点，这是因为我们保留的是「最开始出现的节点」。第二重循环从枚举的保留节点开始，到链表的末尾结束，将所有与保留节点相同的节点全部移除，时间复杂度为O(N^2)。

方法实现

public ListNode removeDuplicateNodes(ListNode head) {
//first节点指向每一轮比较的第一个节点
        ListNode first = head;
        while (first != null) {
            //scanner节点为每一轮第一个节点之后的节点
            //并依次与first节点比较，如果元素值相同则过滤掉
            ListNode scanner = first.next;
            //scanner节点的前驱节点
            ListNode pre = first;
            while (scanner != null) {
                if (first.val == scanner.val) {
                    pre.next = scanner.next;
                } else {
                    pre = scanner;
                }
                //让scanner指向下一个节点并与first节点比较
                scanner = scanner.next;
            }
            //依次选取下一个节点作为第一个节点
            first = first.next;
        }
        return head;
    }

Q2.2 返回倒数第 k 个节点

实现一种算法，找出单向链表中倒数第 k 个节点。返回该节点的值。

注意：本题相对原题稍作改动

示例：

输入： 1->2->3->4->5 和 k = 2
输出： 4

解题思路

这是典型的双指针游走题目，设有两个指针 p1，p2 ：
初始时，两个指针均指向 head。
先将p2向后移动 k 次。此时p1，p2的距离为 k。
同时移动 p1，p2, 直到 p2 指向null。此时p1.val即为答案。
如下图所示：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int kthToLast(ListNode head, int k) {
        ListNode p1 = head;
        ListNode p2 = head;
        int count = 1;
        while (count <= k) {
            p2 = p2.next;
            ++count;
        }
        while (p2 != null) {
            p1 = p1.next;
            p2 = p2.next;
        }
        return p1.val;
    }
}

Q2.3 删除中间节点

实现一种算法，删除单向链表中间的某个节点（即不是第一个或最后一个节点），假定你只能访问该节点。

示例：

输入：单向链表a->b->c->d->e->f中的节点c
结果：不返回任何数据，但该链表变为a->b->d->e->f

解题思路

解法一：与后结点交换数值，然后删除后结点
​ 思路：由于只能访问当前结点，删除元素一般需要前置结点，所以可以把当前结点的值与后结点交换再删除后结点
​ 分析：时间复杂度是常数级，效率很快，不需要额外内存空间

//解法一：与后结点交换数值，再删除后结点
public static void test1(ListNode node) {
    ListNode next_node = node.next;
    //交换两个结点的值
    int temp = next_node.val;
    next_node.val = node.val;
    node.val = temp;
    //下面删除next_node
    node.next=next_node.next;
    //测试
    /*while(node!=null){
        System.out.println(node.val);
        node=node.next;
    }*/
}

方法二：

class Solution {
    public void deleteNode(ListNode node) {
        //删除当前节点node ，可以删去其下一个节点，
        //并将下一个节点的值赋值给当前节点
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

Q2.4 分割链表

编写程序以 x 为基准分割链表，使得所有小于 x 的节点排在大于或等于 x 的节点之前。如果链表中包含 x，x 只需出现在小于 x 的元素之后(如下所示)。分割元素 x 只需处于“右半部分”即可，其不需要被置于左右两部分之间。

示例:

输入: head = 3->5->8->5->10->2->1, x = 5
输出: 3->1->2->10->5->5->8

class Solution {
    /*
        这个题目的意思其实是：将所有小于 x 的节点放在 x 节点之前
          例如：   
            [1,4,3,2,5,2]   3 -> [1, 2, 2, 3, 4, 5]
            [3, 5, 8, 5, 10, 2, 1] 5 -> [1, 2, 3, 5, 5, 8, 10]

        方法： 双指针
             cur 为遍历的当前节点。pre 为遍从前向后第一个未交换的节点
             cur 向后遍历过程总若遇到小于 x 的元素 则与pre 进行交换
     */
    public ListNode partition(ListNode head, int x) {
        ListNode cur = head;
        ListNode pre = head;

        while (cur != null) {
            if (cur.val < x) {
                swap(cur, pre);
                pre = pre.next;
            }
            cur = cur.next;
        }

        return head;
    }

    public void swap(ListNode p1, ListNode p2) {
        int temp = p1.val;
        p1.val = p2.val;
        p2.val = temp;
    }
}

Q2.5 链表求和

给定两个用链表表示的整数，每个节点包含一个数位。这些数位是反向存放的，也就是个位排在链表首部。编写函数对这两个整数求和，并用链表形式返回结果。这些数位是反向存放的，也就是个位排在链表首部。编写函数对这两个整数求和，并用链表形式返回结果。

示例：

输入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295
输出：2 -> 1 -> 9，即912
进阶：假设这些数位是正向存放的，请再做一遍。

示例：

输入：(6 -> 1 -> 7) + (2 -> 9 -> 5)，即617 + 295
输出：9 -> 1 -> 2，即912

思路：
用递归解法，分别从两个链表的第一个节点开始，取一个值相加，相加的结果对10取模，取模得到值作为结果的一位节点。重复上述操作再从两个链表的下一位取值相加( 注 意 得 加 上 前 一 次 操 作 的 进 位 ) \color{red}{(注意得加上前一次操作的进位)}(注意得加上前一次操作的进位)，结果存入结点，通过递归将这些节点连接起来。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    
		//add为求和函数    
        ListNode res = add(l1, l2, 0);
        return res;
    }

	//head1和head2分别为两个链表的第一个元素,value为上一次操作的进位
    static ListNode add(ListNode head1,ListNode head2, int value) {
        if (head1 == null && head2 == null) {
            if (value == 1) {
            	//最后还有进位需要生成最后一个值为1的节点
                return new ListNode(1);
            } else {
            	//已完成最后一位的相加操作，开始逐层返回
                return null;
            }
        }
        if (head1 != null) {
        	//链表1要相加的那位不为空就把值加上
            value += head1.val;
        }
        if (head2 != null) {
        	//链表2要相加的那位不为空就把值加上
            value += head2.val;
        }
        //如果两个值相加后>=10就会产生进位，对10取模可得到减去进位的值
        ListNode res = new ListNode(value % 10);
        //如果两位相加的值小于10则没有进位，即进位为0
        //如果两位相加的值>=10,则要向高位进1
        //此处value值的意义变成了向高位的进位
        value = value < 10 ? 0 : 1;
        
        //此处的三目运算符功能是防止产生空指向异常，只有head1或者head2
        //不为空的情况才下才有next节点
        //传入的value值为向高位的进位
        res.next = add(head1==null?null:head1.next, head2==null?null:head2.next, value);
        return res;
    }
}

Q2.6 回文链表

编写一个函数，检查输入的链表是否是回文的。
示例 1：

输入： 1->2
输出： false
示例 2：

输入： 1->2->2->1
输出： true

class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head == null || head.next == null){
            return true;
        }
        //找到链表中间点
        ListNode low = head;
        ListNode fast = head;
        while(fast != null && fast.next != null){
            low = low.next;
            fast = fast.next.next;
        }
        if(fast != null){//说明有奇数个结点,low需要再走一步。
            low = low.next;
        }
        //翻转后半段链表
        ListNode cur = low.next;
        low.next = null;
        while(cur != null){
            ListNode temp = cur.next;
            cur.next = low;
            low = cur;
            cur = temp;
        }
        //比较前后段是否一致
        while(low != null){
            if(low.val != head.val){
                return false;
            }
            low = low.next;
            head = head.next;
        }
        return true;
    }
}

Q2.7 链表相交

给定两个（单向）链表，判定它们是否相交并返回交点。请注意相交的定义基于节点的引用，而不是基于节点的值。换句话说，如果一个链表的第k个节点与另一个链表的第j个节点是同一节点（引用完全相同），则这两个链表相交。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Reference of the node with value = 2
输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
解释：这两个链表不相交，因此返回 null。

注意：

如果两个链表没有交点，返回 null 。
在返回结果后，两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

总结：

1.这里是单项链表，不可能出现剪刀形状的相交。

2.这里的是的相交是下面的情况

3.让两个节点分别从一个链表的首部开始，走完一个链表重新走另外一个链表，如果相遇必然相交，因为走的路径都是AD+DC+BD

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
      if(headA==null||headB==null)
      {
            return null;
      }
      ListNode p1=headA;
      ListNode p2=headB;
      while(p1!=p2)
      {
      p1=p1==null? headB:p1.next;
      p2=p2==null? headA:p2.next;
      }
     return p1;
     }
}

Q2.8 环路检测

给定一个链表，如果它是有环链表，实现一个算法返回环路的开头节点。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：tail connects to node index 1
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：tail connects to node index 0
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：no cycle
解释：链表中没有环。

/**
 * 判断链表是否有环：
 * 设置快指针和慢指针，慢指针每次走一步，快指针每次走两步
 * 当快指针与慢指针相等时，就说明该链表有环
 */
public boolean isRinged(Node head){
	if(head == null){
		return false;
	}
	Node slow = head;
	Node fast = head;
	while(fast.next != null && fast.next.next != null){
		slow = slow.next;
		fast = fast.next.next;
		if(fast == slow){
			return true;
		}        
	}
	return false;
}

Q2.9  给定一个有环链表，实现一个算法返回环路的开头结点

(1)创建两个指针：FastPointer和SlowPointer。

(2)SlowPointer每走一步，FastPointer就走两步。

(3)两者碰在一起时，将SlowPointer指向LinkedListHead，FastPointer保持不变。

(4)以相同速度移动SlowPointer和FastPointer，一次一步，然后返回新的碰撞处。

LinkedListNode findBegining(LinkedListNode head) {
	LinkedListNode slow = head;
	LinkedListNode fast = head;
 
	/*找出碰撞处，将处于链表中LOOP_SIZE-k步的位置*/
	while(fast != null && fast.next != null) {
		slow = slow.next;
		fast = fast.next.next;
		if(slow == fast) { // 碰撞
			break;
		}
	}
 
	/*错误检查，没有碰撞处，也即没有回路*/
	if(fast == null || fast.next == null) {
		return null;
	}
 
	/*将slow指向首部，fast指向碰撞处，两者距离环路
	 *起始处k步，若两者以相同速度移动，则必定会在环
	 *路起始处碰在一起*/
	slow = head;
	while(slow != fast) {
		slow = slow.next;
		fast = fast.next;
	}
 
	/*至此两者均指向环路起始处*/
	return fast;
}

参考：https://blog.csdn.net/universe_ant/article/details/70215648