双向链表

1.双端链表
1.1内部实现

package Doublelist;
//双端链表，（相比单链表，多个尾节点与首节点的链接引用）
public class DoubleLinklist {
     private Node first;// 首个链接点，相当于车头
     private Node last;  // 尾部链接点
     public DoubleLinklist() {
    	 first = null; //其链默认指向null
     }
     //判断是否为空
     public boolean isEmpty() {
    	 return (first==null);
     }
     //在头节点后插入一个节点
     public void insertfirst(long value) {
    	 Node curr = new Node(value);
    	 if(isEmpty()){//判断是否为插入的第一个节点
    		 last = curr;//第一个节点为尾节点
    	 } 
    	 curr.next = first;  //插入节点指向首节点指向的节点
    	 first = curr;       //首节点指向插入节点first = curr.next表示指向curr的下一个
     }
     //从尾节点后插入一个节点
     public void insertlast(long value) {
    	 Node curr = new Node(value);
//    	 Node curr = last;
//     	 Node selast = last;
    	 if(isEmpty()) {
    		 first =curr;
    	 }else {
    		 last.next = curr;
    	 }
    	 last = curr; 
     }
     //在头节点后删除一个节点
    public Node removefirst() {
    	if(first.next==null) //判断后面有么有节点
    		{
    		last = null;
    	}
    	Node temp = first;  //定义当前节点
    	first = temp.next;  //直接跳过first.next,从而指向第三个节点
    	return temp;
    }
    //显示链表
    public void display1() {
    	Node curr = first;
    	while(curr != null) //判断当前有元素存在
    	{
    		curr.display();  //调用Node里面的显示方法
    		curr = curr.next;//继续遍历下个节点
    	}
    	System.out.println();
    }
    //查找链节点
    public  Node  find(long value) {
    	Node curr = first;
    	while(curr.data!=value) {
    		if(curr.next==null) {
    			return null;
    		}
    		curr = curr.next;
    	}
    	return curr;		
    }
    //删除节点
    public Node delete(long value) {
    	Node curr = first;
    	Node prev = first;
    	while(curr.data!=value) {
    		if(curr.next==null) {
    			return null;
    		}
    		prev = curr;     //之前的要指向当前的链接点
    		curr = curr.next;//当前的链接点要指向下一个
    		if(curr==first) //判断删除节点是否为首节点
    		{
    			first = first.next;
    			}
    		else {
    				prev.next = curr.next; //删除当前的节点prev(prev.next)》curr(curr.next)》node
    			}
    	}
    	return curr;
    }
}

2.双向链表:即手牵手的形式，每个元素均知道自己前后的链接点

2.1链表定义

package Doublelist;
//链节点，有数据域和指针域构成
public class Node {
   public long data; //数据域
   public Node next; //后指针域
   public Node prev; //前指针域

   public Node(long value) {
	   this.data = value;
   }
   public void display() {
	   System.out.print(data+" ");
   }
}

2.2内部功能实现

package Doublelist;
//双向链表，（相互链接，可以知道自己前后链接的元素）
public class Doublelist {
     private Node first;// 首个链接点，相当于车头
     private Node last;  // 尾部链接点
     public Doublelist() {
    	 first = null; //其链默认指向null
     }
     //判断是否为空
     public boolean isEmpty() {
    	 return (first==null);
     }
     //在头节点后（第一个节点前）插入一个节点
     public void insertfirst(long value) {
    	 Node curr = new Node(value);
    	 if(isEmpty()){//判断是否为插入的第一个节点
    		 last = curr;//第一个节点为尾节点
    	 } else {
    		 first.prev = curr;//相当于每次在第一个节点前面插入节点（头节点+第一个节点）
    	 }
    	 curr.next = first;  //插入节点指向首节点指向的节点
    	 first = curr;       //进行第一个节点更新
     }
     //从尾节点后插入一个节点 
     public void insertlast(long value) {
    	 Node curr = new Node(value);
    	 if(isEmpty()) {
    		 first =curr;//设置头节点为新添加节点
    	 }else {
    		 last.next = curr;  //尾节点后面的为新添加节点
    		 curr.prev = last;  //新添加节点的前面节点为尾节点  
    	 }
    	 last = curr; //进行最后节点的更新
     }
     //在头节点后删除一个节点
    public Node removefirst() {
    	Node temp = first;   //定义当前节点
    	if(first == null) {
    		return null;
    	}
    	if(first.next==null) //判断头节点后面有没有节点
    		{
    		last = null;     //直接删除最后一个节点
    	}else { 
    		first.next.prev =null;	//头节点的下个节点前面为空
    	}
    	first = temp.next;  //直接跳过first.next,从而指向第三个节点
    	return temp;
    }
    //从尾节点前面进行删除节点
    public Node removelast() {
    	Node temp = last;
    	if(first.next==null) //判断头节点后面有没有节点
		{
		first = null;     //无，将头节点置空
	}else { 
		last.prev.next =null;	//删除最后一个节点
		last = temp.prev;   //最后节点进行更新
	}
    	return temp;         
    }
    //显示链表
    public void display1() {
    	Node curr = first;
    	while(curr != null) //判断当前有元素存在
    	{
    		curr.display();  //调用Node里面的显示方法
    		curr = curr.next;//继续遍历下个节点
    	}
    	System.out.println();
    }
    //查找链节点
    public  Node  find(long value) {
    	Node curr = first;
    	while(curr.data!=value) {
    		if(curr.next==null) {
    			return null;
    		}
    		curr = curr.next; //继续遍历下个节点
    	}
    	return curr;	//找到返回当前节点	
    }
    //删除节点
    public Node delete(long value) {
    	Node curr = first;
    	while(curr.data!=value) {
    		if(curr.next==null) {
    			return null;
    		}
    	}
    		if(curr==first) //判断删除节点是否为首节点
    		{
    			first = first.next; //跳过第一个节点，即删除当前第一个节点
    			}
    		else {
    				curr.prev.next = curr.next; //删除当前的节点prev(prev.next)》curr(curr.next)》node
    			}
    		curr = curr.next;//当前的链接点要指向下一个
    	
    	return curr;
    }
}

2.3双向链表测试代码

package Doublelist;

public class TestDoublelist {
public static void main(String[] args) {
	Doublelist t1 = new Doublelist();
	//从尾部插入节点
	t1.insertlast(25);
	t1.insertlast(34);
	t1.insertlast(12);
	t1.insertlast(48);
	t1.display1();
	//从尾部删除节点，留一个
    while(!t1.isEmpty()) {
    	t1.removelast();
    	t1.display1();
    }
    //从头部插入节点
    t1.insertfirst(48);
    t1.insertfirst(25);
    t1.insertfirst(36);
	t1.display1();
	//从头部删除节点
	t1.removefirst();
	t1.display1();
	//删除指定元素
	t1.delete(25);
	t1.display1();
	System.out.println("----end---");
	
}
}