LeetCode 删除链表中某个元素
package com.LeetCodeProblem.ListNodeRemoveElement;
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; }
}
package com.LeetCodeProblem.ListNodeRemoveElement;
public class Solution {
public ListNode RemoveElements(int val,ListNode head){
while (head!=null&&head.val==val){
ListNode delNode = head;
head=head.next;
delNode.next=null;
}
if(head==null)
return head;
ListNode prev = head;
while (prev.next!=null){
if(prev.next.val==val){
ListNode delNode = prev.next;
prev.next=delNode.next;
delNode.next=null;
}
else
prev=prev.next;
}
return head;
}
}
或者
package com.LeetCodeProblem.ListNodeRemoveElement;
public class Solution {
public ListNode RemoveElements(int val,ListNode head){
while (head!=null&&head.val==val){
head=head.next;
}
if(head==null)
return head;
ListNode prev = head;
while (prev.next!=null){
if(prev.next.val==val){
prev.next=prev.next.next;
}
else
prev=prev.next;
}
return head;
}
}
或者使用虚拟头节点
package com.LeetCodeProblem.ListNodeRemoveElement;
public class Solution {
public ListNode RemoveElements(int val,ListNode head){
ListNode dummyHead = new ListNode(1);
dummyHead.next=head;
ListNode prev = dummyHead;
while (prev.next!=null){
if(prev.next.val==val){
prev.next=prev.next.next;
}
else
prev=prev.next;
}
return dummyHead.next;
}
}
本地调试算法
package com.LeetCodeProblem.ListNodeRemoveElement;
import java.util.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; }
//链表节点的构造函数
//使用arr为参数,创建一个链表,当前的ListNode为链表头节点
public ListNode(int[]arr){
if(arr==null||arr.length==0)
throw new IllegalArgumentException("链表为空或链表长度为0");
this.val=arr[0];
ListNode cur=this;
for (int i = 1; i < arr.length; i++) {
cur.next=new ListNode(arr[i]);
cur=cur.next;
}
}
//以当前节点为头节点的链表信息字符串
@Override
public String toString(){
StringBuilder res = new StringBuilder();
ListNode cur=this;
while (cur!=null){
res.append(cur.val+"->");
cur=cur.next;
}
res.append("Null");
return res.toString();
}
}
package com.LeetCodeProblem.ListNodeRemoveElement;
public class Solution {
public ListNode RemoveElements(int val,ListNode head){
ListNode dummyHead = new ListNode(1);
dummyHead.next=head;
ListNode prev = dummyHead;
while (prev.next!=null){
if(prev.next.val==val){
prev.next=prev.next.next;
}
else
prev=prev.next;
}
return dummyHead.next;
}
public static void main(String[] args) {
int[] nums={1,2,3,45,6,6,6,8,2};
ListNode head=new ListNode(nums);
System.out.println(head);
ListNode res= (new Solution()).RemoveElements(6,head);
System.out.println(res);
}
}
递归
本质:将原来的问题转化为同一更小的问题
package com.LeetCodeProblem;
public class Sum {
public static int sum(int arr[]){
return sum(arr,0);
}
//计算arr[l...n)这个区间内所有数字的和
private static int sum(int[]arr,int l){
if(l==arr.length)
return 0;
return arr[l]+sum(arr,l+1);
}
public static void main(String[] args) {
int[] nums={1,2,3,4,5,6,7,8};
System.out.println(sum(nums));
}
}
链表天然的递归性
解决链表中删除元素的问题
package com.LeetCodeProblem.ListNodeRemoveElement;
public class Solution2 {
public ListNode RemoveElements(int val,ListNode head){
if(head==null) return head;
ListNode res=RemoveElements(val,head.next);
if (head.val==val) return res;
else {
head.next=res;
return head;
}
}
public static void main(String[] args) {
int[] nums={1,2,3,45,6,6,6,8,2};
ListNode head=new ListNode(nums);
System.out.println(head);
ListNode res= (new Solution()).RemoveElements(6,head);
System.out.println(res);
}
}
package com.LeetCodeProblem.ListNodeRemoveElement;
public class Solution2 {
public ListNode RemoveElements(int val,ListNode head){
if(head==null) return head;
head.next=RemoveElements(val,head.next);
return head.val==val?head.next:head;
}
public static void main(String[] args) {
int[] nums={1,2,3,45,6,6,6,8,2};
ListNode head=new ListNode(nums);
System.out.println(head);
ListNode res= (new Solution()).RemoveElements(6,head);
System.out.println(res);
}
}
递归函数的微观解读
从左到右,再从右到左。
本质是函数调用,只不过调用的是自己。
递归调用的代价:函数调用+系统栈空间
对于线性递归调用,如果计算如十万个数字的累加,系统栈空间就不够用了
递归算法的调试
递归深度depth
package com.LeetCodeProblem.ListNodeRemoveElement;
class Solution2 {
public ListNode RemoveElements(int val,ListNode head,int depth){
String depthString=generateDepthString(depth);
System.out.print(depthString);
System.out.println("call:remove "+val+" in "+head);
if(head==null) {
System.out.print(depthString);
System.out.println("return "+head);
return head;
}
ListNode res =RemoveElements(val,head.next,depth+1);
System.out.print(depthString);
System.out.println("after remove"+val+":"+res);
ListNode ret;
if (head.val==val)ret=res;
else {
head.next=res;
ret=head;
}
System.out.print(depthString);
System.out.println("return "+ret);
return ret;
}
private String generateDepthString(int depth){
StringBuilder res = new StringBuilder();
for (int i = 0; i < depth; i++)
res.append("-");
return res.toString();
}
public static void main(String[] args) {
int[] nums={1,2,6,3,4,5,6};
ListNode head=new ListNode(nums);
System.out.println(head);
ListNode res= (new Solution2()).RemoveElements(6,head,6);
System.out.println(res);
}
}
结果
1->2->6->3->4->5->6->Null
------call:remove 6 in 1->2->6->3->4->5->6->Null
-------call:remove 6 in 2->6->3->4->5->6->Null
--------call:remove 6 in 6->3->4->5->6->Null
---------call:remove 6 in 3->4->5->6->Null
----------call:remove 6 in 4->5->6->Null
-----------call:remove 6 in 5->6->Null
------------call:remove 6 in 6->Null
-------------call:remove 6 in null
-------------return null
------------after remove6:null
------------return null
-----------after remove6:null
-----------return 5->Null
----------after remove6:5->Null
----------return 4->5->Null
---------after remove6:4->5->Null
---------return 3->4->5->Null
--------after remove6:3->4->5->Null
--------return 3->4->5->Null
-------after remove6:3->4->5->Null
-------return 2->3->4->5->Null
------after remove6:2->3->4->5->Null
------return 1->2->3->4->5->Null
1->2->3->4->5->Null
双链表
循环链表
数组链表
按顺序合并两个链表并输出
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
// 类似归并排序中的合并过程
ListNode dummyHead = new ListNode(0);
ListNode cur = dummyHead;
while (l1 != null && l2 != null) {
if (l1.val < l2.val) {
cur.next = l1;
cur = cur.next;
l1 = l1.next;
} else {
cur.next = l2;
cur = cur.next;
l2 = l2.next;
}
}
// 任一为空,直接连接另一条链表
if (l1 == null) {
cur.next = l2;
} else {
cur.next = l1;
}
return dummyHead.next;
}