链表的相关题解
文章目录
1.移除链表元素
思路
1.先找到这个值的节点,然后看这个节点在哪个位置
2.如果在头结点则头结点后移
3.不在头结点则定义一个辅助指针,遍历链表
4.找到要移除节点的前一位,然后让前一个节点的next指向下一个的下一个节点
代码实现
package com.algo.linkedlist;
public class Algo203 {
public ListNode removeElements(ListNode head, int val) {
//如果链表为空,直接返回
if(head == null){
return head;
}
while (head.val == val){
if(head.next!=null){//如果头结点的值为要移除节点的值 则让头结点后移
head = head.next;
}else{
return null;
}
}
//定义一个辅助指针,遍历链表
ListNode temp = head;
while (temp.next!=null){
if(temp.next.val==val){//找到要移除节点的前一位
temp.next = temp.next.next;//让前一个节点的next指向下一个的下一个节点
continue;//跳过本次循环
}
temp = temp.next;//指针后移
}
return head;
}
}
2.设计链表
思路
1.先写一个链表的构造器
2.get(index):获取链表中第 index 个节点的值。如果索引无效,则返回-1。
3.addAtHead(val):在链表的第一个元素之前添加一个值为 val 的节点。插入后,新节点将成为链表的第一个节点。
4.addAtTail(val):将值为 val 的节点追加到链表的最后一个元素。
5.addAtIndex(index,val):在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度,则该节点将附加到链表的末尾。如果 index 大于链表长度,则不会插入节点。如果index小于0,则在头部插入节点。
6.deleteAtIndex(index):如果索引 index 有效,则删除链表中的第 index 个节点。
代码实现
package com.algo.linkedlist;
public class Algo707 {
int size ;//存储链表元素个数
ListNode head;//虚拟头结点
//初始化链表。
public Algo707() {
size = 0;
head = new ListNode(0);
}
//获取链表中下标为 index 的节点的值。如果下标无效,则返回 -1 。
public int get(int index) {
//如果index无意义,返回-1
if(index<0||index>size){
return -1;
}
ListNode currentNode = head;
//包含一个虚拟头节点,所以查找第 index+1 个节点
int i =0;
while (i<=index) {
currentNode = currentNode.next;
i++;
}
return currentNode.val;
}
//将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后,新节点会成为链表的第一个节点。
public void addAtHead(int val) {
addAtIndex(0, val);
}
//将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
public void addAtTail(int val) {
addAtIndex(size, val);
}
//将一个值为 val 的节点插入到链表中下标为 index 的节点之前。
//如果 index 等于链表的长度,那么该节点会被追加到链表的末尾。
//如果 index 比长度更大,该节点将 不会插入 到链表中
public void addAtIndex(int index, int val) {
if (index>size) {
return;
}
if(index<0){
index = 0;
}
size++;
ListNode pred = head;
int i=0;
while (i<index){
i++;
pred = pred.next;
}
ListNode valNode = new ListNode(val, null);
valNode.next = pred.next;
pred.next = valNode;
}
//如果下标有效,则删除链表中下标为 index 的节点。
public void deleteAtIndex(int index) {
if(index<0||index>=size){
return;
}
size--;
if(index == 0){
head = head.next;
return;
}
ListNode pred = head;
int i =0;
while (i<index){
pred = pred.next;
i++;
}
pred.next = pred.next.next;
}
}
3.翻转链表
思路(栈)
1.首先将所有的结点入栈
2.然后创建一个虚拟虚拟头结点,让cur指向虚拟头结点。
3.然后开始循环出栈
4.每出来一个元素,就把它加入到以虚拟头结点为头结点的链表当中,最后返回即可。
代码实现
package com.algo.linkedlist;
import java.util.Stack;
public class Algo206 {
/**
* Definition for singly-linked list.
* 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; }
* }
*/
public ListNode reverseList(ListNode head) {
/**
* 首先将所有的结点入栈
* 然后创建一个虚拟虚拟头结点,让cur指向虚拟头结点。然后开始循环出栈,
* 每出来一个元素,就把它加入到以虚拟头结点为头结点的链表当中,最后返回即可。
*/
if (head == null || head.next == null) {
return head;
}
Stack<ListNode> stack = new Stack<>();
ListNode cur = head;
//将所有节点入栈
while (cur!=null){
stack.push(cur);
cur = cur.next;
}
//定义一个虚拟头结点
ListNode newhead = new ListNode(0,null);
//指向虚拟头结点
cur = newhead;
//如果栈中还有元素 则一直出栈 出栈之后让辅助指针后移
while (stack.size()!=0){
cur.next = stack.pop();
cur = cur.next;
}
//当到最后一个元素的时候,让最后一个元素指向null
cur.next=null;
return newhead.next;
}
}
思路(双指针)
1.首先定义一个cur指针,指向头结点,再定义一个pre指针,初始化为null
2.首先要把 cur.next 节点用temp指针保存一下
3.要改变 cur->next 的指向了,将cur->next 指向pre ,此时已经反转了第一个节点了
4.接下来,就是循环走如下代码逻辑了,继续移动pre和cur指针
5.最后,cur 指针已经指向了null,循环结束,链表也反转完毕了。 此时我们return pre指针就可以了,pre指针就指向了新的头结点
代码实现
package com.algo.linkedlist;
import java.util.Stack;
public class Algo206 {
/**
* Definition for singly-linked list.
* 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; }
* }
*/
public ListNode reverseList(ListNode head) {
/**
* 双指针
* 首先定义一个cur指针,指向头结点,再定义一个pre指针,初始化为null。
*
* 首先要把 cur.next 节点用temp指针保存一下。
*
* 要改变 cur->next 的指向了,将cur->next 指向pre ,此时已经反转了第一个节点了。
*
* 接下来,就是循环走如下代码逻辑了,继续移动pre和cur指针。
*
* 最后,cur 指针已经指向了null,循环结束,链表也反转完毕了。 此时我们return pre指针就可以了,pre指针就指向了新的头结点
*/
ListNode prev = null;
ListNode cur = head;
ListNode temp = null;
while (cur!=null){
temp = cur.next;
cur.next = prev;
prev = cur;
cur = temp;
}
return prev;
}
}
思路(虚拟头节点)
1.定义一个虚拟头结点
2.定义一个辅助指针,遍历原始数组
3.定义一个节点,指向当前节点的下一个位置
4.先保存辅助指针指向的下一个节点
5.再让辅助指针的next指向虚拟头结点的下一个
6.再让虚拟头结点的next指向辅助指针
7.让辅助指针指向刚才保存的节点
代码实现
package com.algo.linkedlist;
import java.util.Stack;
public class Algo206 {
/**
* Definition for singly-linked list.
* 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; }
* }
*/
public ListNode reverseList(ListNode head) {
if(head==null||head.next==null){
return head;
}
//定义一个辅助指针,遍历原始链表
ListNode cur = head;
ListNode next = null;//定义一个节点,指向当前节点的下一个位置
ListNode newHead = new ListNode(0,null);//创建一个新的头节点
while (cur!=null){
next = cur.next;
cur.next = newHead.next;
newHead.next = cur;
cur = next;
}
head = newHead.next;
return head;
}
}
4.两两交换链表中的节点
力扣:24. 两两交换链表中的节点 - 力扣(Leetcode)
思路
1.定义一个虚拟头结点,虚拟头结点的next指向head
2.再定义两个指针,分别为左指针,右指针
3.再定义一个辅助指针temp,用来遍历链表
4.当temp的next和temp的next的next不为空时,就让两个左右指针交换元素
5.交换完后再让temp指向右节点下一个的节点
代码实现
package com.algo.linkedlist;
public class Algo24 {
public ListNode swapPairs(ListNode head) {
//双指针法
//如果链表为空或者链表中只有一个元素 直接返回
if(head==null||head.next==null){
return head;
}
//定义一个虚拟头结点
ListNode newHead =new ListNode(0,null);
newHead.next = head;
//定义两个辅助指针
ListNode left;
ListNode right;
ListNode temp = newHead;
while (temp.next!=null&&temp.next.next!=null){
left = temp.next;
right = temp.next.next;
temp.next = right;
left.next = right.next;
right.next = left;
temp = left;
}
return newHead.next;
/*
//递归 太深奥
//如果链表为空或者链表中只有一个元素 直接返回
if(head==null||head.next==null){
return head;
}
// 获取当前节点的下一个节点
ListNode next = head.next;
// 进行递归
ListNode newNode = swapPairs(next.next);
// 这里进行交换
next.next = head;
head.next = newNode;
return next;*/
}
}
5.删除链表的倒数第N个节点
力扣:19. 删除链表的倒数第 N 个结点 - 力扣(Leetcode)
思路
1.先定义一个虚拟头结点,让虚拟头结点的next指向head
2.定义两个指针,分别为left和right,让right先移动n次
3.再让两个指针同时移动,当right移动到最后一位时,left所指就是要删除节点的前一个
4.让left.next==left.next.next
代码实现
package com.algo.linkedlist;
public class Algo19 {
public ListNode removeNthFromEnd(ListNode head, int n) {
//定义一个虚拟头结点
ListNode newHead = new ListNode(0,null);
newHead.next = head;
//定义两个辅助指针
ListNode left = newHead;
ListNode right = newHead;
//先让一个节点移动n次
for (int i = 0; i < n; i++) {
right = right.next;
}
//再让left和right同时移动,移动到right的下一个节点为空
//总之right与left一直相差n个节点 当right指向尾结点时right指的就是要删除节点的前一个
while (right.next!=null){
left = left.next;
right = right.next;
}
left.next = left.next.next;
return newHead.next;
}
}
6.链表相交
力扣:面试题 02.07. 链表相交 - 力扣(Leetcode)
思路
1.先分别遍历两个链表,统计两个链表分别有多少个元素
2.然后计算出元素多的链表比少的链表多多少个元素
3.让链表元素个数多的先移动元素个数之差次
4.让两个指针同时移动,当两个指针指向同一个节点,就说明找到相交的节点了
5.没有找到就返回null
代码实现
package com.algo.linkedlist;
public class Algo160 {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
//第一步,分别遍历两个链表 分别统计出有多少个元素
int countA = 0;
int countB = 0;
ListNode tag = null;//如果相交,则用此变量来保存相交的起始节点
ListNode temp = headA;
while (temp != null) {
temp = temp.next;
countA++;
}
//当跳出循环时就统计出了headA中的元素个数
temp = headB;
while (temp != null) {
temp = temp.next;
countB++;
}
//当跳出循环时就统计出了headB中的元素个数
ListNode curA = headA;
ListNode curB = headB;
if (countA > countB) {//如果headA的元素多余headB的元素,则先将A中的辅助指针向右移动countA-countB次
for (int i = 0; i < countA - countB; i++) {
curA = curA.next;
}
}else {
for (int i = 0; i < countB - countA; i++) {
curB = curB.next;
}
}
//移动后再同时移动两个辅助指针,当两个指针所指节点为同一节点时就表明找到了 否则没找到
while (curA != null && curB != null) {
if (curA == curB) {
tag = curA;
break;
}
//同时后移
curA = curA.next;
curB = curB.next;
}
//跳出循环后,如果tag==null,表明没找到
if (tag == null) {
return null;
} else {
return tag;
}
}
}
7.环形链表
力扣:142. 环形链表 II - 力扣(Leetcode)
思路
1.先判断是否有环,定义两个指针,先同时指向头结点
2.一个指针每次走两步,一个指针每次走一步,当他们指向同一个节点时就说明有环
3.否则就没有环,当有环时就需要分析环的头结点在哪儿
4.当两个节点指向同一个节点时,让快的节点再次指向头节点,然后让他们同时移动
5.当两个指针再次相遇的时候就是环的头结点,返回这个头节点
代码实现
package com.algo.linkedlist;
public class Algo160 {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
//第一步,分别遍历两个链表 分别统计出有多少个元素
int countA = 0;
int countB = 0;
ListNode tag = null;//如果相交,则用此变量来保存相交的起始节点
ListNode temp = headA;
while (temp != null) {
temp = temp.next;
countA++;
}
//当跳出循环时就统计出了headA中的元素个数
temp = headB;
while (temp != null) {
temp = temp.next;
countB++;
}
//当跳出循环时就统计出了headB中的元素个数
ListNode curA = headA;
ListNode curB = headB;
if (countA > countB) {//如果headA的元素多余headB的元素,则先将A中的辅助指针向右移动countA-countB次
for (int i = 0; i < countA - countB; i++) {
curA = curA.next;
}
}else {
for (int i = 0; i < countB - countA; i++) {
curB = curB.next;
}
}
//移动后再同时移动两个辅助指针,当两个指针所指节点为同一节点时就表明找到了 否则没找到
while (curA != null && curB != null) {
if (curA == curB) {
tag = curA;
break;
}
//同时后移
curA = curA.next;
curB = curB.next;
}
//跳出循环后,如果tag==null,表明没找到
if (tag == null) {
return null;
} else {
return tag;
}
}
}