递归实现---------链表

//链表本身是具有天然递归性。
public class LinkedListRecursion<E> implements List<E> {
	
	private class Node{
		E data;		//数据域
		Node next;	//指针域
		public Node(){
			this(null,null);
		}
		public Node(E data,Node next){
			this.data=data;
			this.next=next;
		}
		@Override
		public String toString() {
			return data.toString();
		}
	}
	private Node head;	//指向虚拟头结点的头指针
	private Node rear;	//指向尾结点的尾指针
	private int size;	//记录元素的个数
	
	public LinkedListRecursion() {
		head=new Node();
		rear=head;
		size=0;
	}
	
	@Override
	public int getSize() {
		return size;
	}

	@Override
	public boolean isEmpty() {
		return size==0&&head.next==null;
	}



	@Override
	public void add(int index, E e) {
		if(index<0||index>size){
			throw new IllegalArgumentException("插入角标非法!");
		}
		Node n=new Node(e,null);
		if(index==0){	//头插
			n.next=head.next;
			head.next=n;
			if(size==0){
				rear=n;
			}
		}else if(index==size){	//尾插
			rear.next=n;
			rear=rear.next;
		}else{	//一般插入             
			head.next=add(head.next,0,index,n); //调用辅助函数
		}
		size++;
	}
	/**
	 * 以节点p为头结点的链表中插入结点n
	 * i只当前p的角标
	 * index插入结点的位置
	 * */
	private Node add(Node p,int i,int index,Node n){
		if(i==index-1){
			n.next=p.next;
			p.next=n;
		}else{
			p.next=add(p.next,i+1,index,n);
		}
		return p;
	}
	@Override
	public void addFirst(E e) {
		add(0,e);
	}

	@Override
	public void addLast(E e) {
		add(size,e);
	}

	@Override
	public E get(int index) {
		if(index<0||index>=size){
			throw new IllegalArgumentException("查找角标非法!");
		}
		if(index==0){	//获取头
			return head.next.data;
		}else if(index==size-1){	//获取尾
			return rear.data;
		}else{	//获取中间
			return get(head.next,0,index);
		}
	}
	/**
	 * 返回以p为头结点的链表中 角标在index处的结点元素
	 * i表示当前p的角标
	 * */
	//人用迭代 神用递归
	private E get(Node p,int i,int index){
		if(i==index){
			return p.data;
		}else{
			return get(p.next,i+1,index);
		}
	}
	@Override
	public E getFirst() {
		return get(0);
	}

	@Override
	public E getLast() {
		return get(size-1);
	}

	@Override
	public void set(int index, E e) {
		if(index<0||index>=size){
			throw new IllegalArgumentException("修改角标非法!");
		}
		if(index==0){	//改头
			head.next.data=e;
		}else if(index==size-1){	//改尾
			rear.data=e;
		}else{
			set(head.next,0,index,e);
		}
	}
	private void set(Node p,int i,int index,E e){
		if(i==index){
			p.data=e;
		}else{
			set(p.next,i+1,index,e);
		}
	}
	@Override
	public boolean contains(E e) {
		return find(e)!=-1;
	}

	@Override
	public int find(E e) {
		if(isEmpty()){
			return -1;
		}
		
		return find(head.next,0,e);
	}

	private int find(Node p,int i,E e){
		if(p==null){
			return -1;
		}else{
			if(p.data==e){
				return i;
			}else{
				return find(p.next,i+1,e);
			}
		}
	}
	
	@Override
	public E remove(int index) {
		if(index<0||index>=size){
			throw new IllegalArgumentException("删除角标非法!");
		}
		E res=null;
		if(index==0){	//头删
			Node p=head.next;
			res=p.data;
			head.next=p.next;
			p.next=null;
			p=null;
			if(size==1){
				rear=head;
			}
		}else{
			head.next=remove(head.next,0,index);
		}
		size--;
		return res;
	}
	private Node remove(Node p,int i,int index){
		if(i==index-1){
			System.out.println(">>>"+p.next.data);
			p.next=p.next.next;
			if(index==size-1){
				rear=p;
			}
		}else{
			p.next=remove(p.next, i+1, index);
		}
		return p;
	}
	@Override
	public E removeFirst() {
		return remove(0);
	}

	@Override
	public E removeLast() {
		return remove(size-1);
	}

	@Override
	public void removeElement(E e) {
		
	}

	@Override
	public void clear() {
		
	}
	@Override
	public String toString() {
		StringBuilder sb=new StringBuilder();
		sb.append("LinkedList:size="+getSize()+"\n");
		if(isEmpty()){
			sb.append("[]");
		}else{
			sb.append("[");
			Node p=head;
			while(p.next!=null){
				p=p.next;
				if(p==rear){
					sb.append(p.data+"]");
				}else{
					sb.append(p.data+",");
				}
			}
		}
		return sb.toString();
	}
}

插入代码递归：

//链表使用 虚拟头结点去是实现的
private Node add(Node p , int i , int index , Node n){
//递归的边界
	if( i == index -1 ){ //当前 i 是  index位置的前驱  即 index -1 的位置
		n.next = p.next;
		p.next = n;
	}else{
		p.next = add(p.next , i+ 1 , index ,n);
	}
 return p;


}

最后返回一个 链表 这个表 是 添加完后的表

//用辅助函数
privat E get(Node p , int i ,int  index){ //返回角标所在结点的 数据
	if( i == index){
		return p.data;
	}else{
		return get(p.next , i+1 , index)		
	}


}

//set 和 get方法 相似

private void set(Node p , int i , int index , E e)[
	if( i == index){
	p.data = e;

	}else{
		set(p.next , i + 1 , index ,e);
	}


}

```java
public int find(E e){
	if( isEmpty()){
		return -1;
	}
	return find(head.next,0,e);

}
//先找节点 如果结点存在的话 ，去判断 是否 存在这个数据 
private int find(Node p , int i ,E e){
	if(p == null){
		return -1;


	}else{
		if( p.data == e){
		return i;
		}else{
			return find(p.next , i+ 1 ,e);
		}
	}



}

//删除  删除尾 1.需查2.需删  一般删1.需查2.需删  所以一起写
//返回的是一个 数 ，但是改变了链表 所以也要返回 结点  那么如何处理
private Node  remove(Node p , int i , int index){
	if(i == index - 1){
		System.out.println("---" + p.next.data);
		p.next = p.next.next;
		if(index == size -1){
 			rear = p;
		}
	}else{
		p.next = reamove(p.next , i+ 1 , index);

	}

	return p;

}