链表OJ题练习记录
题目列表
- 链表结构
- 1.删除链表中等于给定值 val 的所有节点
- 2. 反转一个单链表。
- 3. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。
- 4. 输入一个链表，输出该链表中倒数第k个结点。
- 5. 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
- 6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前
- 7. 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。
- 8. 链表的回文结构。
- 9. 输入两个链表，找出它们的第一个公共结点.
- 10. 给定一个链表，判断链表中是否有环。
- 11. 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null .
链表结构(牛客网)4,6,7,8题
链表结构
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
链表结构(leetcode)1,2,3,5,9,10,11题
public class ListNode {
int val;
ListNode next;
ListNode() {}
ListNode(int val) { this.val = val; }
ListNode(int val, ListNode next) { this.val = val; this.next = next; }
1.删除链表中等于给定值 val 的所有节点
public ListNode removeElements(ListNode head, int val) {
//不加傀儡节点,先删除其余节点,最后处理头结点.
if(head == null){
return null;
}
//prev为删除节点的前一个
ListNode prev = head;
//待删除节点
ListNode cur = head.next;
for (;cur!=null;){
if (cur.val == val){
prev.next = cur.next;
cur = prev.next;
}else{
prev = prev.next;
cur = cur.next;
}
}
//最后检测头结点是否为要删除元素的情况
if(head.val == val){
head = head.next;
}
return head;
}
//加傀儡节点
public ListNode removeElements(ListNode head, int val) {
//傀儡节点
ListNode realhead = new ListNode();
realhead.next = head;
ListNode delete = head;
head = realhead;
//
while (delete != null) {
if (delete.val == val) {
head.next = delete.next;
delete = delete.next;
}else{
head = head.next;
delete = delete.next;
}
}
//head 不带傀儡节点;
return realhead.next;
}
将原来的链表添加了一个傀儡节点,将头结点在结构上转化为普通节点.从而简化代码.
2. 反转一个单链表。
//遍历头插 带傀儡节点
ListNode newhead = new ListNode();
ListNode next;
while (head != null) {
next = head;
head = head.next;
next.next = newhead.next;
newhead.next = next;
}
return newhead.next;
在遍历原链表的时候,创建新的链表并用头插法进行插入将其倒置
//不带傀儡节点
ListNode prev = null;
ListNode cur = head;
ListNode newhead = null;
while(cur != null){
//防止nextNode.next的时候为空出现空指针异常
//nextNode.next = nextNode
ListNode nextNode = cur.next;
if(nextNode == null){
newhead = cur;
}
cur.next = prev;
prev = cur;
cur = nextNode;
}
return newhead;
递归调用:
if (head == null || head.next == null) {
return head;
}
//每次递归都返回的是最后一个节点
ListNode reverse = reverseList(head.next);
head.next.next = head;
head.next = null;
return reverse;
递归调用在使用上比较优雅但是比较难理解.要常使用来熟悉操作.
参考题解链接
3. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。
public ListNode middleNode(ListNode head) {
ListNode slow = head;
ListNode fast = head;
//偶数跳出 奇数跳出
while (fast !=null && fast.next!= null){
slow = slow.next;
fast = fast.next.next;
}
return slow;
}
利用快慢指针进行遍历,对奇数节点和偶数节点情况进行判断,
4. 输入一个链表，输出该链表中倒数第k个结点。
public static ListNode FindKthToTail(ListNode head,int k) {
//链表间隔
if(k <= 0 || head==null){
return null;
}
ListNode fast = head;
ListNode slow = head;
for (int i = 0; i < k; i++) {
if(fast == null){
return null;
}else{
fast = fast.next;
}
}
for (; fast!=null ;fast = fast.next,slow = slow.next) {
}
return slow;
}
先处理特殊情况如k的取值小于零和传入链表为空的情况，然后使用循环将快指针先使用循环向后k次，然后将两个节点同时向后推移直到快指针到达末尾。
5. 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
双指针法，因为合并之前两个指针都是有序的，所以在最后只需要判断是因为那个引用的地址为空将另外一个引用后续节点全部链接就可以了。
public static ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode head = new ListNode();
ListNode i = head;
while (l1 != null && l2!=null ){
if(l1.val <= l2.val){
i.next = l1;
i = l1;
l1 = l1.next;
}else {
i.next = l2;
i = l2;
l2 = l2.next;
}
}
if(l1 == null){
i.next = l2;
}
if(l2 == null){
i.next = l1;
}
return head.next;
}
递归解法
6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前
public static ListNode partition(ListNode pHead, int x) {
if(pHead == null){
return null;
}
ListNode headBig = new ListNode(1);
ListNode headBigend = headBig;
ListNode headSmall = new ListNode(1);
ListNode headSmallend = headSmall;
while (pHead != null){
if(pHead.val >= x){
headBigend.next = pHead;
headBigend = pHead;
}else {
headSmallend.next = pHead;
headSmallend = pHead;
}
pHead = pHead.next;
}
headBigend.next = null;
headSmallend.next = headBig.next;
return headSmall.next;
}
创建两个链表头结点,比较值对链表进行分割,最后将链表合并,小数字在前大数字在后.
注意: 大数字节点被放在后面在最后要手动将末尾节点的next所存放的地址进行赋值null否则链表将会形成环,从而运行超时.
7. 在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。
public static ListNode deleteDuplication(ListNode pHead) {
ListNode head = pHead;
ArrayList<Integer> list = new ArrayList<>();
ArrayList<Integer> deleteList = new ArrayList<>();
while (head !=null){
if(list.contains(head.val)){
deleteList.add(head.val);
}
list.add(head.val);
head = head.next;
}
list.removeAll(deleteList);
ListNode newhead = new ListNode(1);
ListNode end = newhead;
for (int i :
list) {
end.next = new ListNode(i);
end = end.next;
}
return newhead.next;
}
第一次尝试使用了ArrayList结合进行链表数据的遍历,将每一个重复的数据存储到deletList集合,然后使用list.removeAll方法对list集合进行了删除.最后创建新的链表并返回就完成了.
缺点 : 没有想到比较巧妙的方法,在时间和空间上都比较惨.在没能正确理解题意,查看题解发现重复的值都是相邻的.
ListNode head = new ListNode(1);
head.next = pHead;
ListNode per = head;
ListNode cur = head.next;
while (cur !=null){
if(cur.next != null && cur.val == cur.next.val){
while (cur.next != null && cur.val == cur.next.val){
cur = cur.next;
}
cur = cur.next;
per.next = cur;
}else {
per = cur;
cur = cur.next;
}
}
return head.next;
奇怪的是 使用原链表上修改的方法 发现在内存占用上并没有什么优化.
8. 链表的回文结构。
OJ地址
题干要求
对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。
空间复杂度为O(n)
ListNode head = A;
ListNode end = new ListNode(-1);
int i = 0;
int j = 0;
while (head != null){
ListNode newnode = new ListNode(head.val);
newnode.next = end;
end = newnode;
i++;
head = head.next;
}
for (;A.val == end.val && j < i/2 ; A = A.next,end = end.next,j++){
}
if(j == i/2){
return true;
}
return false;
遍历原链表并用头插法创建新链表同时计数,头插法的顺序和之前相反,用for循环遍历判断如果是j ==i/2条件结束的那么为回文链表,如果因为A.val == end.val不满足而结束就是因为不满足回文条件.
空间复杂度为O(1)
ListNode fast = A;
ListNode slow = A;
while (fast.next != null && fast.next.next != null) {
slow = slow.next;
fast = fast.next.next;
}
//快慢指针找出中间结点
ListNode nextMid = slow.next;
slow.next = null;
ListNode prev = null;
ListNode next = null;
//中间结点之后倒序重组
while (nextMid != null){
next = nextMid.next;
nextMid.next = prev;
prev = nextMid;
nextMid = next;
}
//依次比较返回结果
while(A != null && prev != null){
if(A.val != prev.val){
return false;
}
A = A.next;
prev = prev.next;
}
return true;
循环未开始
第一次循环结束
第二次循环结束
9. 输入两个链表，找出它们的第一个公共结点.
if(headA == null || headB == null) {
return null;
}
ListNode per = headA;
ListNode cur = headB;
HashSet<ListNode> set = new HashSet<>();
while (per !=null){
set.add(per);
per = per.next;
}
while (cur != null){
if(set.contains(cur)){
return cur;
}
cur = cur.next;
}
return null;
检查是否重复的时候可以尝试多考虑Hashset集合,HashSet集合底层为一个哈希表结构在查询速度上非常快 并且 不允许存储重复元素.
if(headA == null || headB == null){
return null;
}
ListNode per = headA;
ListNode cur = headB;
while (per != cur) {
per = per == null ? headB : per.next;
cur = cur == null ? headA : cur.next;
}
return per;
题解里看到的双指针法,通过巧妙的交换将长度差进行消除,从而让两个链表的长度变成相同的.
两图截图与leetcode用户王小二的题解.
10. 给定一个链表，判断链表中是否有环。
给定一个链表，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
ListNode per = head;
int i = 0;
HashMap<ListNode,Integer> hashMap = new HashMap<>();
while (per!=null){
if(hashMap.containsKey(per)){
return true;
}
hashMap.put(per,i++);
per = per.next;
}
return false;
题干看得有点迷,弄岔了
if(head == null){
return false;
}
ListNode fast = head;
ListNode slow = head;
while (fast != null && fast.next != null ){
fast = fast.next.next;
slow = slow.next;
if(fast == slow){
return true;
}
}
return false;
常用的快慢指针的方法,如果存在环,那么快慢指针总会相遇.
查看题解可以发现还有反转链表,逐个删除的方法.后续补充.
11. 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null .
ListNode per = head;
int i = 0;
HashMap<ListNode,Integer> hashMap = new HashMap<>();
while (per!=null){
if(hashMap.containsKey(per)){
return per;
}
hashMap.put(per,i++);
per = per.next;
}
return null;
和上一个题区别在返回值.
if(head == null){
return null;
}
ListNode fast = head;
ListNode slow = head;
while (fast != null && fast.next != null ){
fast = fast.next.next;
slow = slow.next;
if(fast == slow){
fast = head;
while (fast != slow){
fast = fast.next;
slow = slow.next;
}
return fast;
}
}
return null;
经典双指针,但是因为要返回链表开始入环的节点所以我们队之前代码进行修改.
具体思路可以看leetcode题解链接
739
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
