最近用Java写了一些算法题，在这里分类总结一下，主要是剑指offer上的，下边就直接给相关代码实现，不多做解释了，可以直接看代码读懂。类名后边的数字是剑指offer书上的题号，题目都是在牛客网上AC的，但是它们的那个平台的方法入口名有些不规范
删除链表中重复的结点
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
*/
/**
* 题目描述：在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，
* 重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
* 删除值相等的链表，全部删除
* 经典的三指针操作
*/
public class DeleteDuplication57 {
public ListNode deleteDuplication(ListNode pHead) {
if (pHead == null) {
return null;
}
//虚拟头节点，来解决头节点相等的问题
ListNode preHead = new ListNode(0);
ListNode pre = preHead;
ListNode node = pHead;
pre.next = node;
//是否有相等的节点的标志位，因为此题是将有相等的节点全部删除
boolean flag = false;
ListNode next;
while (node != null) {
next = node.next;
//相等判断条件
while (next != null && node.val == next.val) {
next = next.next;
flag = true;
}
//如果有相等的话，则删除全部值。此时next指向的是第一个不相等节点，此情况下，pre指针是不需要移动的
if (flag) {
pre.next = next;
node = next;
flag = false;
} else {
//不相等，则移动pre，node和next，进行下一步比较
pre = node;
node = node.next;
}
}
return preHead.next;
}
}链表的环的入口结点
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
*/
/**
* 题目描述：一个链表中包含环，请找出该链表的环的入口结点。
* 此问题有两种解法： 1. 双指针，一步两步，相遇于环中，然后记录相遇点，再让一个指针走到此点，记录走的步数则为k，就是环的大小
则再让两个指针从头开始，一个指针先走k步，然后一起走，再次相遇的点即是环的入口点
2. 快慢指针，相遇，然后另一个再从头开始，再次相遇的点即是入口点（此性质可以进行证明，将路径分段）
要注意：边界，快慢指针的判断，以及判断是否有环
*/
public class EntryNodeOfLoop56 {
public ListNode entryNodeOfLoop(ListNode pHead) {
if (pHead == null) {
return null;
}
ListNode node1 = getTheMeetingPoint(pHead);
// 说明此链表无环
if (node1 == null) {
return null;
}
// 第二轮相遇点即是入口
ListNode node2 = pHead;
while (node1 != node2) {
node1 = node1.next;
node2 = node2.next;
}
return node1;
}
/**
* 快慢指针获得相遇点。
* return null 的话，说明，无环
*/
public ListNode getTheMeetingPoint(ListNode pHead) {
if(pHead == null) {
return null;
}
ListNode p1 = pHead;
ListNode p2 = pHead;
while (p2 != null) {
p1 = p1.next;
p2 = p2.next;
if (p2 != null) {
p2 = p2.next;
}
// 指针引用都是指向一个地址的，所以可以直接相等判断
if (p1 == p2) {
return p1;
}
}
return null;
}
}
两个链表的第一个公共节点
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
/**
* 题目描述:输入两个链表，找出它们的第一个公共结点。
* 两条链表形成的是Y型。所以先遍历两个链表的长度，相差k步，再一步步前进。
* 注意其实现细节
*/
public class FindFirstCommonNode37 {
public ListNode findFirstCommonNode(ListNode pHead1, ListNode pHead2) {
if (pHead1 == null || pHead2 == null) {
return null;
}
ListNode pNode1 = pHead1;
ListNode pNode2 = pHead2;
int len1 = 0;
int len2 = 0;
// 分别求两个链表的长度
while (pNode1 != null) {
pNode1 = pNode1.next;
len1++;
}
while (pNode2 != null) {
pNode2 = pNode2.next;
len2++;
}
// 再重置其位置
pNode1 = pHead1;
pNode2 = pHead2;
// 让长的那个链表先走k步
if (len1 > len2) {
for (int i = 1; i <= len1 - len2; i++) {
pNode1 = pNode1.next;
}
}
if (len2 > len1) {
for (int i = 1; i <= len2 - len1; i++) {
pNode2 = pNode2.next;
}
}
// 注意比较的是值，因为这是两个链表
while (pNode1 != null && pNode2 != null && pNode1.val != pNode2.val) {
pNode1 = pNode1.next;
pNode2 = pNode2.next;
}
return pNode1;
}
}链表中倒数第k个结点
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
/**
题目描述:输入一个链表，输出该链表中倒数第k个结点。
* 1. 两个指针，一个先走k步，再和另一个一起走，可以实现一次遍历即可找到倒数第k个
注意边界：如果先走k步，则判断条件是p1指针是否为null，如果走k-1步，则判断条件是p1.next是否为null
相当于后一个只遍历到最后一个节点即停止
2. 遍历两次的做法：获得链表长度，然后直接遍历到 len - k位置
*/
public class FindKthToTail15 {
public ListNode FindKthToTail(ListNode head,int k) {
if (head == null || k <= 0) {
return null;
}
ListNode p1 = head;
ListNode p2 = head;
// p1 指针先走k步
while (k > 0) {
if (p1 == null) {
return null;
}
k--;
p1 = p1.next;
}
// p1 p2 再一起走
while (p1 != null) {
p2 = p2.next;
p1 = p1.next;
}
return p2;
}
}约瑟夫环问题
import java.util.LinkedList;
/**
* 约瑟夫环问题：1. 用链表来模拟环
* 2. 归纳规律
*/
public class JosephLoop45 {
public int LastRemaining_Solution(int n, int m) {
if (n <= 0 || m <= 0) {
return -1;
}
LinkedList<Integer> list = new LinkedList<>();
// 初始化编号
for(int i = 0; i < n; i++) {
list.add(i);
}
// 模拟约瑟夫问题
int start = 0; // 报数起始点
int count = 1; // 用来记录是否该出队了
while(list.size() > 1 ) {
int len = list.size();
while(count < m) {
count++;
start++;
// 环形来遍历
if (start >= len) {
start = 0;
}
}
list.remove(start);
count = 1;
// 要判断是否上一步出队的是最后一个，要不然会有空指针问题
if (start == len - 1) {
start = 0;
}
}
return list.get(start);
}
}合并两个有序的链表
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
/**
* 题目描述:输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
* 合并操作，参考归并排序的合并过程
*/
public class MergeSortedList17 {
public ListNode Merge(ListNode list1,ListNode list2) {
if (list1 == null) {
return list2;
}
if (list2 == null) {
return list1;
}
//虚拟头结点
ListNode head = new ListNode(0);
ListNode list = head;
while (list1 != null && list2 != null) {
if (list1.val < list2.val) {
ListNode node = new ListNode(list1.val);
list.next = node;
list = list.next;
list1 = list1.next;
} else {
ListNode node = new ListNode(list2.val);
list.next = node;
list = list.next;
list2 = list2.next;
}
}
while (list1 != null) {
ListNode node = new ListNode(list1.val);
list.next = node;
list = list.next;
list1 = list1.next;
}
while (list2 != null) {
ListNode node = new ListNode(list2.val);
list.next = node;
list = list.next;
list2 = list2.next;
}
return head.next;
}
}从尾到头打印链表
/**
* public class ListNode {
* int val;
* ListNode next = null;
*
* ListNode(int val) {
* this.val = val;
* }
* }
*
*/
import java.util.ArrayList;
/**
* 题目描述:输入一个链表，从尾到头打印链表每个节点的值。
* 1. 利用集合容器保存一下 存在空间复杂度
2. 利用递归实现，利用递归深度实现 递归也存在空间复杂度
3. 翻转链表实现，如果可以改变原序列的话
*/
public class PrintListFromTailToHead05 {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
//如果不声明成全局变量就用返回值来实现
ArrayList<Integer> list = new ArrayList<Integer>();
if (listNode == null) {
return list;
}
list.addAll(printListFromTailToHead(listNode.next));
list.add(listNode.val);
return list;
}
}复杂链表的复制
/*
public class RandomListNode {
int label;
RandomListNode next = null;
RandomListNode random = null;
RandomListNode(int label) {
this.label = label;
}
}
*/
/**
* 此问题，有三种解决方法
1. 最容易想到的，O(n^2)解法，第一步将复制next指针，第二步对于每一个节点，都需要O(n)的时间来查找random指针的位置
2. 时间复杂度O(n) 空间复杂度O(n) 可以看到，最费时间的是对于random指针的确定，所以可以利用一个hash表，
<n,n'> 保存原链表与复制链表的映射，所以对于n的random指针指向s，可以利用O(1)的时间来获得n'对应的random指针s'
3. 时间复杂度O(n) 空间复杂度O(1)的解法，分三步 第一步 连接next n1->n1'->n2->n2'....
第二步 连接random n1->s1 对应 n1'->s1.next
第三不 拆分链表为两个链表
*/
public class RandomListNodeClone26 {
public RandomListNode Clone(RandomListNode pHead) {
if (pHead == null) {
return null;
}
connectNext(pHead);
connectRandom(pHead);
return splitList(pHead);
}
//第一步：复制链表 next
public void connectNext(RandomListNode pHead) {
RandomListNode node = pHead;
while (node != null) {
RandomListNode copyNode = new RandomListNode(node.label);
copyNode.next = node.next;
node.next = copyNode;
node = copyNode.next;
}
}
//第二步：连接链表：random指针
public void connectRandom(RandomListNode pHead) {
RandomListNode node = pHead;
while(node != null) {
RandomListNode copyNode = node.next;
if (node.random != null) {
copyNode.random = node.random.next;
}
node = copyNode.next;
}
}
//第三步：拆分链表
public RandomListNode splitList(RandomListNode pHead) {
RandomListNode node = pHead;
RandomListNode copyHead = pHead.next;
RandomListNode copyNode = copyHead;
while (node != null) {
node.next = copyNode.next;
node = node.next;
//如果node已经是最后一个节点了，所以node.next指向了null，null.next就会报空指针，
//所以要加一个判断，解决最后一个节点
if (node != null) {
copyNode.next = node.next;
copyNode = copyNode.next;
}
}
return copyHead;
}
}翻转链表
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
/**
* 题目描述:输入一个链表，反转链表后，输出链表的所有元素。
* 翻转链表，要记录前中后，肯定要三个指针。注意第一个指针，指向null，第二个指针指向head，会很容易实现翻转链表
*/
public class ReverseList16 {
public ListNode reverseList(ListNode head) {
if (head == null) {
return null;
}
ListNode pre = null;
ListNode node = head;
while (node != null) {
ListNode next = node.next;
node.next = pre;
pre = node;
node = next;
}
return pre;
}
}
扫一扫
9638
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
