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



/* * 基于双向链表实现双端队列结构 */ package dsa; public class Deque_DLNode implements Deque { protected DLNode header;//指向头节点(哨兵) protected DLNode trailer;//指向尾节点(哨兵) protected int size;//队列中元素的数目 //构造函数 public Deque_DLNode() { header = new DLNode(); trailer = new DLNode(); header.setNext(trailer); trailer.setPrev(header); size = 0; } //返回队列中元素数目 public int getSize() { return size; } //判断队列是否为空 public boolean isEmpty() { return (0 == size) ? true : false; } //取首元素(但不删除) public Object first() throws ExceptionQueueEmpty { if (isEmpty()) throw new ExceptionQueueEmpty("意外:双端队列为空"); return header.getNext().getElem(); } //取末元素(但不删除) public Object last() throws ExceptionQueueEmpty { if (isEmpty()) throw new ExceptionQueueEmpty("意外:双端队列为空"); return trailer.getPrev().getElem(); } //在队列前端插入新节点 public void insertFirst(Object obj) { DLNode second = header.getNext(); DLNode first = new DLNode(obj, header, second); second.setPrev(first); header.setNext(first); size++; } //在队列后端插入新节点 public void insertLast(Object obj) { DLNode second = trailer.getPrev(); DLNode first = new DLNode(obj, second, trailer); second.setNext(first); trailer.setPrev(first); size++; } //删除首节点 public Object removeFirst() throws ExceptionQueueEmpty { if (isEmpty()) throw new ExceptionQueueEmpty("意外:双端队列为空"); DLNode first = header.getNext(); DLNode second = first.getNext(); Object obj = first.getElem(); header.setNext(second); second.setPrev(header); size--; return(obj); } //删除末节点 public Object removeLast() throws ExceptionQueueEmpty { if (isEmpty()) throw new ExceptionQueueEmpty("意外:双端队列为空"); DLNode first = trailer.getPrev(); DLNode second = first.getPrev(); Object obj = first.getElem(); trailer.setPrev(second); second.setNext(trailer); size--; return(obj); } //遍历 public void Traversal() { DLNode p = header.getNext(); while (p != trailer) { System.out.print(p.getElem()+" "); p = p.getNex
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值