（Java笔记学习8）双端链表和双向链表

双端链表和双向链表

一、什么是双端链表。

      链表中保存着对最后一个链节点引用的链表。

二、从头部进行插入

      要对链表进行判断，如果为空则设置尾节点为新添加的节点。

三、从尾部进行插入

      如果链表为空，则直接设置头结点为新添加的节点，否则设置尾节点的后一个节点为新添加节点。

四、从头部进行删除

      判断头结点是否为下一个结点，如果没有则设置为结点为null。

双端链表的好处就是可以从尾结点进行添加

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

//双端链表
public class FirstLastLinkList {
	private Node first;
	
	private Node last;
	
	public FirstLastLinkList(){
		first=null;
		last=null;
	}
	/*
	 * 从头结点开始插入
	 * */
	public void insertFirst(long value){
		Node newnode=new Node(value);
		if(isEmpty()){
			last=newnode;
		}
		newnode.next=first;
		first=newnode;
		
	}
	/*
	 * 从尾结点开始插入
	 * */
	public void insertLast(long value){
		Node newnode=new Node(value);
		if(isEmpty()){
			first=newnode;
		}else{
			last.next=newnode;
		}
		last=newnode;
	}
	/*
	 * 从头结点开始删除
	 * */
	public void deleteFirst(){
		if(first.next==null){
			last=null;
		}
		first=first.next;
	}
	/*
	 * 从尾结点开始删除
	 * */
	public void deleteLast(){
		if(first.next==null){
			last=null;
		}
		
	}
	/*
	 * 查找节点,结果返回布尔值
	 * */
	public boolean find(long value){
		Node current=first;
		if(current!=null){
			while(current.data!=value){
				if(current.next==null){
					return false;
				}
				current=current.next;
			}
			if(current.data==value){
				return true;
			}
		}else{
			return false;
		}
		return false;
	}
	/*
	 * 查找方法,结果返回值
	 * */
	public Node findvalue(long value){
		Node current=first;
		while(current.data!=value){
			if(current.next==null){
				return null;
			}
			current=current.next;
		}
		return current;
	}
	/*
	 * 根据数据删除结点,成功则返回true
	 * */
	public boolean deleteNode(long value){
		if(first==null)	{
			return false;	
		}
		if(find(value)){//先要确定是否存在要删除的数据
			Node current=first;
			Node previous=first;
			while(current.data!=value){
				if(current.next==null){
					return false;
				}
				previous=current;
				current=current.next;
			}
			previous.next=current.next;//将结点删除
			return true;
			
		}else{
			return false;
		}	
	}
	/*
	 * 删除方法，根据数据域来进行删除,结果返回被删除数据
	 * */
	public Node delete(long value){
		Node current=first;
		Node previous=first;
		while(current.data!=value){
			if(current.next==null){
				return null;
			}
			previous=current;
			current=current.next;
		}
		
		if(current==first){//如果是第一个节点
			first=first.next;
		}else{
			previous.next=current.next;
		}
		return current;
	}
	/*
	 * 显示方法
	 * */
	public void display(){
		Node current=first;
		while(current!=null){
			current.display();
			current=current.next;
		}
	}
	/*
	 * 判断是否为空链表
	 * */
	public boolean isEmpty(){
		return (first==null);
	}
}
public class TestFirstLastLinkList {
	public static void main(String[] args){
		FirstLastLinkList fl=new FirstLastLinkList();
		//从头结点开始插入数据
		fl.insertFirst(1);
		fl.insertFirst(2);
		fl.insertFirst(5);
		fl.insertFirst(8);
		//从尾结点开始插入数据
		fl.insertLast(5);
		fl.insertLast(10);
		fl.insertLast(0);
		fl.display();
		//查找成功返回true
		System.out.println(fl.find(0));
		/*从头结点开始删除
		while(!fl.isEmpty()){
			fl.deleteFirst();
			fl.display();
		}*/
		
		System.out.println(fl.deleteNode(0));
		fl.display();
		
	}
}







双向链表
一、什么是双向量表。
      每个结点除了保存了对下一个结点的引用，同时还保存着对前一个结点的引用。
二、从头部进行插入
      要对链表进行判断，如果为空则设置尾结点为新添加的节点。如果不为空，还需要设置头结点的前一个结点为新添加的结点。
三、从尾部进行插入
       如果链表为空，则直接设置头结点为新添加的结点，否则设置尾结点的后一个结点为新添加节点。同时设置新添加的结点的前一个节点为尾结点。
四、从头部进行删除
       判断头结点是否有下一个结点，如果没有则设置为结点为null。否则设置头结点的下一个结点为previous为null。
五、从尾部进行删除
       如果头结点后没有其他节点，则设置尾节点为null。否则设置尾节点前一个结点的next为null。设置尾结点为其前一个节点。
六、删除方法。
       不需要再使用一个临时的指针域。


public class Node {
	//数据域
	public long data;
	//指针域
	public Node next;
	public Node previous;
	
	public Node(long value){
		this.data=value;
	}
	/*
	 * 显示方法
	 * */
	public void display(){
		System.out.print(data+" ");
	}
}

public class DoubleLinkList {
	//头结点
	private Node first;
	//尾节点
	private Node last;
	
	public DoubleLinkList(){
		first=null;
	}
	/*
	 * 插入一个节点，在头结点后进行插入
	 * */
	public void insertFirst(long value){
		Node node=new Node(value);
		if(isEmpty()){
			last=node;
		}else{
			first.previous=node;
		}
		node.next=first;
		first=node;
		
	}
	
	/*
	 * 插入一个节点，从尾节点进行插入
	 * 
	 * */
	public void insertLast(long value){
		Node node=new Node(value);
		if(isEmpty()){
			first=node;
		}else{
			last.next=node;
			node.previous=last;
		}
		last=node;
	}
	
	/*
	 * 删除一个节点，在头结点后进行删除
	 * */
	
	public Node deleteFirst(){
		Node tmp=first;
		if(first.next==null){
			last=null;
		}else{
			first.next.previous=null;
		}
		first=tmp.next;
		return tmp;
	}
	/*
	 * 删除结点，从尾部进行删除
	 * */
	public Node deleteLast(){
		Node tmp=last;
		if(first.next==null){
			first=null;
		}else{
			last.previous.next=null;
			last=last.previous;
		}
		return last;
	}
	
	/*
	 * 显示方法
	 * */
	public void display(){
		Node current=first;
		while(current!=null){
			current.display();
			current=current.next;
		}
		System.out.println();
	}
	/*
	 * 查找方法
	 * */
	public Node find(long value){
		Node current=first;
		while(current.data!=value){
			if(current.next==null){
				return null;
			}
			current=current.next;
		}
		return current;
	}
	/*
	 * 删除方法，根据数据域来进行删除
	 * */
	public Node delete(long value){
		Node current=first;
		while(current.data!=value){
			if(current.next==null){
				return null;
			}
			current=current.next;
		}
		
		if(current==first){//如果是第一个节点
			first=first.next;
		}else{
			current.previous.next=current.next;
		}
		return current;
	}
	/*
	 * 判断是否为空
	 * 
	 * */
	public boolean isEmpty(){
		return (first==null);
	}
	
}

public class TestDoubleLinkList {
	public static void main(String[] args){
		DoubleLinkList dl=new DoubleLinkList();
		dl.insertLast(45);
		dl.insertLast(56);
		dl.insertLast(90);
		dl.display();
		//删除尾部结点
		dl.deleteLast();
		dl.display();
		
		while(!dl.isEmpty()){
			dl.deleteLast();
			dl.display();
		}
	}
}