1.关于判断链表是否有环的问题
在解决这类问题上，我个人认为有两种办法：哈希及双指针
那先来看一下如何用哈希去解决这类问题
算法描述：遍历所有的链表的所有结点，将这些个结点全部存在hashset里面，直到下一个结点位null,则结束，如果当前结点已经存在于哈希表里，那么证明有环，反之就没有。
接下来看代码：
1.先定义一个链表类
class ListNode{
int val;
ListNode next;
ListNode(int x){
val=x;
next=null;
}
}
2.再定义一个实例链表测试的主函数
public static void main(String[] args) {
ListNode listNode=new ListNode(3);
ListNode listNode1=new ListNode(2);
ListNode listNode2=new ListNode(0);
ListNode listNode3=new ListNode(-4);
listNode.next=listNode1;
listNode1.next=listNode2;
listNode2.next=listNode3;
listNode3.next=listNode1;
boolean b = hasCycle(listNode);
System.out.println(b);
}
那么实际的链表应该是这样的：
image.png
3.从这个链表实例出发可以看到我们调用了hasCycle（）方法去判断是否有环，这里先用hashSet去实现。
public static boolean hasCycle1(ListNode head){
//base判断
if(head==null||head.next==null){
return false;
}
//创建容器
Set set=new HashSet();
//循环出口
while(head!=null){
//判断如果包含结点，直接确定是循环连接
if(set.contains(head)){
return true;
}else{
//没有就往里添加
set.add(head);
}
//结点依次往下
head=head.next;
}
//找不到就返回fasle
return false;
}
4使用快慢指针去解题
public static boolean hasCycle(ListNode head){
// base判断
if(head==null||head.next==null){
return false;
}
//指定快慢结点
ListNode fast=head.next;
ListNode slow=head;
//循环出口
while(fast!=null&&fast.next!=null){
//如果快指针走过一圈回来碰到慢指针那肯定有环
if(fast.equals(slow)){
return true;
}
//快慢指针往下走
fast=fast.next.next;
slow=slow.next;
}
//找不到就返回fasle
return false;
}
2.关于链表反转的问题
两种方法：迭代和递归
1.首先看迭代
假设存在链表 1 → 2 → 3 → Ø，我们想要把它改成 Ø ← 1 ← 2 ← 3。
在遍历列表时，将当前节点的 next 指针改为指向前一个元素。由于节点没有引用其上一个节点，因此必须事先存储其前一个元素。在更改引用之前，还需要另一个指针来存储下一个节点。不要忘记在最后返回新的头引用！
public class ReverseListNode {
public static void main(String[] args) {
ReverseListNode reverseListNode = new ReverseListNode();
ListNode l1=new ListNode(3);
ListNode l2=new ListNode(2);
ListNode l3=new ListNode(0);
ListNode l4=new ListNode(-1);
l1.next=l2;
l2.next=l3;
l3.next=l4;
System.out.println(reverseListNode.reverseList(l1));
}
public static ListNode reverseList(ListNode head){
//首先定义一个空指针，这个空指针定义是要在最头部的
ListNode prev=null;
//然后将curr指向head
ListNode curr=head;
//一步步迭代,出口就是curr=null的时候
while(curr!=null){
//先拿到curr的下一个指针
ListNode temp=curr.next;
//然后把当前的结点指向prev，即指向前一个结点
curr.next=prev;
//更新curr和prev的值，把prev往后移一位
prev=curr;
//再把当前结点往后移一位
curr=temp;
//就这样依次迭代，直到curr==null的时候跳出
}
//然后返回prev
return prev;
}
}
运行结果：
ListNode{val=-1, next=ListNode{val=0, next=ListNode{val=2, next=ListNode{val=3, next=null}}}}
Process finished with exit code 0
最终完成了反转。
1.再看递归
递归的解法很难理解，
递归的两个条件：
终止条件是当前节点或者下一个节点==null
在函数内部，改变节点的指向，也就是 head 的下一个节点指向 head 递归函数那句
head.next.next = head
很不好理解，其实就是 head 的下一个节点指向head。
递归函数中每次返回的 cur 其实只最后一个节点，在递归函数内部，改变的是当前节点的指向。
public static ListNode reverseList1(ListNode head){
//先确定递归的终止条件
if(head==null||head.next==null){
return head;
}
//先拿到最后一个结点curr
ListNode curr = reverseList1(head.next);
//如果链表是 1->2->3->4->5，那么此时的cur就是5
//而head是4，head的下一个是5，下下一个是空
//所以head.next.next 就是5->4
head.next.next=head;
//防止链表循环，将head.next=null
head.next=null;
//每层递归函数都返回cur，也就是最后一个节点
return curr;
}
结果如下：
ListNode{val=-1, next=ListNode{val=0, next=ListNode{val=2, next=ListNode{val=3, next=null}}}}
Process finished with exit code 0
3.再来讨论一个很经典的约瑟夫问题吧，这曾经是我在恒生笔试的一道题，当时一脸懵，现在蹭热再好好讨论一下经典的约瑟夫问题
image.png
public class JosephTest {
public static void main(String[] args) {
Node first=null;
Node pre=null;
for (int i = 1; i <=41; i++) {
//如果是第一个结点
if(i==1){
first=new Node(i,null);
pre=first;
continue;
}
//如果不是第一个结点
Node newNode=new Node(i,null);
//让前一个结点指向这个新节点
pre.next=newNode;
//然后再让pre指针往后移
pre=newNode;
//如果位最后一个结点，则最后一个结点位第一个结点
if(i==41){
pre.next=first;
}
}
//count计数，模拟报数
int count =0;
//记录第一个结点
Node n=first;
//当前结点的前一个结点
Node before=null;
//循环结束的条件n==n.next
while(n!=n.next){
//模拟报数
count++;
//判断是不是3
if(count==3){
//删除
before.next=n.next;
//打印
System.out.println(n.val);
//重置
count=0;
//继续往下
n=n.next;
}else{
//如果不是3.那么继续往下
before=n;
n=n.next;
}
}
System.out.println("最后的元素"+n.val);
}
}
class Node{
int val;
Node next;
public Node(int val, Node next) {
this.val = val;
this.next = next;
}
@Override
public String toString() {
return "Node{" +
"val=" + val +
", next=" + next +
'}';
}
}
最终结果：