动态链表3队列的链式存储结构(LinkedQueue实现)

    1.队列的链式存储结构定义。

•       队列的链式存储结构，其实就是线性表的单链表。这里的队列同样的具备头结点指针head，head位置不存放元素。尾指针rear，rear位置存放元素。
•     空队列的判断，和线性表一样，当元素总和为空时或者头结点的下一跳指向null，也就是head==rear。
•     队列的元素进出特点就和栈的链式不一样了，队列的是先进先出。
•     队列的实现接口是Queue。

    2.LinkedQueue的定义。

    +Linkedlist list                            //队列的链式由线性表的链式实现，创建一个LinkedList<E>类型的变量list

    +LinkedQueue()                        //构造函数的搭建

    +String toString()                      //toString的方法函数

    +boolean equals(Object obj)    //equals的方法函数

    与栈的链式同样，队列的构建一样由线性表的链式实现，与队列的顺序存储有异曲同工之意。可以对照1线性表的顺序存储和2队列的顺序存储加1线性表的链式存储观看琢磨。

    ①进队列图解。

      进队列的意思就是在线性表的最后加入一个元素，每次进都是在队尾进入，之前进的元素都累积在后面。还有的就是，尾指针rear都会移动到进入元素对应的位置。

    ②出队列图解。

      出队列的意思就是在头结点的下一跳删除该位置元素，还有一个需要注意的是，如果这个队列链式只存在一个元素了，那么出队列一个后，尾指针rear就要移动到头指针head的位置，即是队列为空。

    3.队列的链式的toString()方法。

      和栈的链式基本一样。

      1、使用线程不安全的StringBuilder类创建对象sb。

      2、对队列的链式判断是否为空，为空直接返回sb.append("[ ]");。

      3、不为空则先连接sb.append("[");。

      4、之后使用获得元素方法，使用for循环，将元素开始连接，每连接一次，只要未到达最后一个元素，那么后边连接逗号sb.append(',');，当到达最后一个元素后，在最后连接的元素后边连接上sb.append(']');。

public String toString(){
		StringBuilder sb=new StringBuilder();   //1
		if(isEmpty()){	                        //2
			sb.append("[]");
		}else{
			sb.append("[");                 //3
			for(int i=0;i<getSize();i++){   //4
				sb.append(list.get(i));
				if(i==getSize()-1){
					sb.append(']');
				}else{
					sb.append(',');
				}
			}
		}
		
		return sb.toString();
	}

    4.队列的链式的equals(Object obj)方法。

      1、先对传入的对象obj判断是否为空，为空则返回false。

      2、再对该对象obj与this直接判断是否相等，相等直接返回true。

      3、最后比较里边内容，将obj强转成LinkedQueue<E>即可开始。

      4、返回 return this.list.equals(l.list);。

public boolean equals(Object obj){
		if(obj==null){                 //1
			return false;
		}
		if(obj==this.list){            //2
			return true;
		}
		if(obj instanceof LinkedQueue){
			LinkedQueue<E> l=(LinkedQueue<E>) obj; //3
			return list.equals(l.list);//4
		}
		return false;

    5.队列的链式全部代码实现。

package com.oupeng.p5链表;

import com.oupeng.p3队列.Queue;

public class LinkedQueue<E> implements Queue<E> {

	private LinkedList<E> list;    //队列的链式由线性表的链式实现，创建一个LinkedList<E>的变量list
	public LinkedQueue(){
		list=new LinkedList<E>();  //无参构造函数的搭建
	}
	
	@Override
	public int getSize() {         //队列链式获取元素总和
		return list.getSize();     //也就是线性表链式的元素总和，返回
	}

	@Override
	public boolean isEmpty() {     //队列链式判断是否为空
		return list.isEmpty();     //也就是线性表链式是否为空
	}

	@Override
	public void enqueue(E e) {     //队列链式的元素进出是先进先出
		list.addLast(e);           //也就是线性表链式的尾指针下一跳的插入元素e
	}

	@Override
	public E dequeue() {           //队列链式的元素进出是先进先出
		return list.removeFirst(); //也就是线性表链式的头结点下一跳数据data的删除
	}

	@Override
	public E getFront() {          //队列链式第一个元素的获取
		return list.getFirst();    //也就是线性表链式头结点下一跳数据data的获取返回
	}

	@Override
	public E getRear() {           //队列链式最后一个元素的获取，尾指针对应的元素
		return list.getLast();     //也就是线性表链式尾指针对应元素的获取
	}

	@Override
	public void clear() {          //队列链式的整队清空
		list.clear();              //也就是线性表链式的全表清空
	}

	public String toString(){
		StringBuilder sb=new StringBuilder();
		if(isEmpty()){	
			sb.append("[]");
		}else{
			sb.append("[");
			for(int i=0;i<getSize();i++){
				sb.append(list.get(i));
				if(i==getSize()-1){
					sb.append(']');
				}else{
					sb.append(',');
				}
			}
		}
		
		return sb.toString();
	}
	public boolean equals(Object obj){
		if(obj==null){
			return false;
		}
		if(obj==this.list){
			return true;
		}
		if(obj instanceof LinkedQueue){
			LinkedQueue<E> l=(LinkedQueue<E>) obj;
			return list.equals(l.list);
		}
		return false;
	}
}