java数据结构-链表递归（学习链表笔记三）

链表递归针对力扣的203题来进行学习

首先我们用链表解出来

链表的创建代码

 

package com.binglian.LinkedList.digui;

public class ListNode {
	
	public int val;
	public ListNode next;
	

	public ListNode(int x){
		val=x;
	}
	
	//链表节点的结构函数
	//使用arr为参数，创建一个链表，当前的ListNode为链表头为节点
	public ListNode(int[] arr){
		if(arr ==null || arr.length ==0){
			throw new IllegalArgumentException("创建链表的数据不能为空");
		}
		
		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.binglian.LinkedList.digui;


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
public class Solution {

	public ListNode removeElements(ListNode head,int val){
		while(head !=null && head.val ==val){//如果不为空并且头部为val那么就删除 head.val 是指向的值
			ListNode delNode=head;
			head=head.next;
			delNode.next=null;
		}
		
		if(head == null)
			return null;
		
		ListNode prev=head;
		while(prev.next !=null){
			if(prev.next.val ==val){//判断指向的值 是否是val 如果是 就删除
				ListNode delNode=prev.next;
				prev.next=delNode.next;
				delNode.next=null;
			}else {
				prev=prev.next;//如果值的内容都不是val 那么指向下一个
			}
		}
		return head;
	}
	
	public static void main(String[] args){
		int[] nums={1,2,6,3,4,6};
		ListNode head=new ListNode(nums);
		System.out.println(head);
		
		ListNode res=(new Solution()).removeElements(head, 6);
		System.out.println(res);
	}
}

 链表递归

递归其实就是栈，把问题分成若干个小问题

在链表中就是 一个头结点后面连接了一个小链表

递归其实和方法没有多大区别，调用方法，又回到那个调用其他方法的方法中，

就是栈，直到返回为最基本问题的时候，然后在依次倒退,在倒退途中进行计算运行

 

在视频的图，老师是一个很厉害的人，通俗易懂，到后面自己都大概理解，不像其他老师，让我云里雾里的

链表的递归，和方法递归

 

栈的代码，

package com.binglian.LinkedList.digui;

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};
		
	}
}

 我先贴上203使用递归链表解决的代码

package com.binglian.LinkedList.digui;


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

//使用递归进行编写
public class Solution2 {

	public ListNode removeElements(ListNode head,int val){
		if(head ==null)
			return null;
		
		ListNode res=removeElements(head.next, val);
		if(head.val== val)
			return res;
		else {
			head.next=res;
			return head;
		}
	}
	
	public static void main(String[] args){
		int[] nums={1,2,6,3,4,6};
		ListNode head=new ListNode(nums);
		System.out.println(head);
		
		ListNode res=(new Solution2()).removeElements(head, 6);
		System.out.println(res);
	}
}

 

我们在来看一下老师给的动画，我分为两个部分，老师的代码，简洁了很多，我这里没有简洁

我的理解就是，当回到最基本问题的时候，返回空，那么程序就倒退，在执行语句，执行递归的下一个程序，然后一直回到最初调用的时候进行返回最终结果，，这只是我的理解，如果我的理解有问题，请评论在下方，小白的求知欲望

然后看回到最初的递归的下一个图，