Java训练题13

一、选择题

1、单链表实现的栈，栈顶指针为Top(只是一个指针)，入栈一个P节点时，其操作步骤为（B ）
A. Top.next=p;
B. p.next=Top.next;Top.next=p;
C. p.next=Top;Top=p.next;
D. p.next=Top;Top=Top.next;
答案解析：B
根据题意Top只是一个指针，所以Top最后的位置是不能动的；
栈的特点是先入后出，并且只能在表的一段进行操作，所以首先，p要称为链表的第一个有效结点，代码为
p.next=Top.next；
最后头结点指针归位，代码为Top.next=p
2、下列与队列结构有关联的是 （D ）
A. 函数的递归调用
B. 数组元素的引用
C. 多重循环的执行
D. 先到先服务的作业调度
答案解析：D
队列的特点就是先入先出，最后一个刚好是符合队列的特点的；A相中递归调用相关联的结构是栈
3、以下 （B ） 不是队列的基本运算
A. 从队尾插入一个新元素
B. 从队列中删除第i个元素
C. 判断一个队列是否为空
D. 读取队头元素的值
答案解析：B
队列只能在两端进行操作，无法直接操作队列中间的元素
4、字符 A 、 B 、 C 依次进入一个栈，按出栈的先后顺序组成不同的字符串，至多可以组成 ( ) 个不同的字符串（ B）
A. 14
B. 5
C. 6
D. 8
答案解析：B
入栈顺序可以为ABC，但是出栈可以为ABC，BAC，ACB，CBA，BCA，所以有5种不同的字符串
5、判断一个循环队列Q（最多元素为m）为满队列的条件是（B ）
A. rear+1=front
B. (rear+1)%m=front
C. rear=front
D. (rear+1)%m=null
答案解析：B
循环队列中队列为空的条件为rear=front
循环队列中会空一个空格来区别队列满还是空，所以队列的最后一个位置不存放元素，那么队列未满的条件是：
(rear+1)%m=front

二、编程题

1、反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。OJ链接

示例1:
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例2:
输入：head = [1,2]
输出：[2,1]

【解题思路】：
三种思路:1.递归法，将第二个节点之后的链表反转交给子函数，返回链表最新的头结点，然后和当前头结点连接即
可。2.边遍历原链表边用头插法插入新链表，得到的新链表值恰好是原链表的反转。3.使用cur和prev引用，原链表
的指向是prev->next，修改指向的链表变为cur->prev.

class Solution {
// 1.递归法
	public ListNode reverseList(ListNode head) {
		if (head == null || head.next == null) {
		return head;
		}
		ListNode sec = head.next;
		// 2.反转第二个节点之后的子链表
		ListNode newHead = reverseList(head.next);
		// 3.将sec.next = head;
		// head.next = null;
		sec.next = head;
		head.next = null;
		return newHead;
	}
	// 2.原地移动
	public ListNode reverseList(ListNode head) {
		if (head == null || head.next == null) {
			return head;
		}
		ListNode prev = null;
		// 当前需要处理的节点(需要反转)
		ListNode cur = head;
		while (cur != null) {
			// 暂存一下下一个需要处理的节点
			ListNode next = cur.next;
			cur.next = prev;
			prev = cur;
			cur = next;
		}
		return prev;
	}
}

2、找到链表环的入口
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。不允许修改链表。
OJ链接

示例1:
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。
示例2:
输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。
示例2:
输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环

【解题思路】：
我们使用两个指针，fast 与 slow。它们起始都位于链表的头部。随后，slow 指针每次向后移动一个位置，而 fast 指
针向后移动两个位置。如果链表中存在环，则 fast 指针最终将再次与slow 指针在环中相遇。
如下图所示，设链表中环外部分的长度为 a。slow 指针进入环后，又走了 b 的距离与fast 相遇。此时，fast 指针已
经走完了环的 n 圈，因此它走过的总距离为 a+n(b+c)+b=a+(n+1)b+nc。

根据题意，任意时刻，fast 指针走过的距离都为slow 指针的 2 倍。因此，我们有 a+(n+1)b+nc=2(a+b)⟹a=c+(n−1)(b+c)
有了a=c+(n−1)(b+c) 的等量关系，我们会发现：从相遇点到入环点的距离加上 n−1 圈的环长，恰好等于从链表头部到入环点的距离。
因此，当发现 slow 与 fast 相遇时，我们再额外使用一个指针 third。起始，它指向链表头部；随后，它和slow 每次向后移动一个位置。最终，它们会在入环点相遇。

public class Solution {
	public ListNode detectCycle(ListNode head) {
		ListNode fast = head,low = head;
		while (fast != null && fast.next != null) {
			fast = fast.next.next;
			low = low.next;
			// 此时fast和low相遇
			if (fast == low) {
				ListNode third = head;
				while (third != low) {
					third = third.next;
					low = low.next;
				}
			return low;
			}
		}
		return null;
	}
}