Java数据结构之队列与栈的基本操作

本篇博客将提供以下功能的代码：

• 队列的基本操作：建立队列的链式存储结构，实现队列的初始化、enqueque\dequeue等基本功能。
• 栈的基本操作：建立栈的线性存储结构，实现栈的初始化、pop、push、get等基本功能。

代码

队列的接口

//队列的特点：先进先出
public interface QQueue<T> {
	//判空
	boolean isEmpty();
	//入队
	void add(T item);
	//头删
	void poll();
	//取出队头元素
	T peek();
}

队列结点类

public class Node<T> {
	 T data;
		//Java内没有指针的定义
		//Java的引用是指向一个对象，它是占一个新内存的；
		//而C++的引用则是指向同一个内存的另外一个名字，也就是常说的别名。
		 Node<T> next;
		 public Node(T data,Node next)
		 {
			 this.data=data;
			 this.next=next;
		 }
	     public Node()
		 {
			 this.data=null;
			 this.next=null;
		 }
	     public Node(T data)
		 {
			 this.data=data;
			 this.next=null;
		 }
}

队列实现类

public class LinkedQueue<T> implements QQueue<T> {
	private Node<T> head=new Node<T>();

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

	//尾插吗？？？？
	@Override
	public void add(T item) {
		Node<T> tmp=new Node<>();
		Node<T> newnode=new Node<>(item);
		tmp=this.head;
		while(tmp.next!=null)
		{
			tmp=tmp.next;
		}
		tmp.next=newnode;
	}

	@Override
	public void poll() {
		assert(!this.isEmpty());
		//找到最后一个结点的前一个结点
		/*
		Node<T> tmp=new Node<>();
	
		tmp=this.head;
		while(tmp.next.next!=null)
		{
			tmp=tmp.next;
		}
		
		tmp.next=null;*/
		this.head.next=this.head.next.next;
	}

	//取出队头的元素
	@Override
	public T peek() {
		assert(!this.isEmpty());
		return this.head.next.data;
	}
}

栈的接口

//栈的特点：先进后出
public interface SStack<T> {
	//判空
	boolean isEmpty();
	//入栈
	void push(T item);
	//出栈
	T pop();
	//取出栈顶元素
	T peek();
}

栈的实现类

public class SeqStack<T> implements SStack<T> {
	private Object arr[];//用顺序表来实现栈
	public int len=0;//表示栈的长度或者说是元素的个数
	private int capacity=4;
	
	SeqStack()
	{
		this.arr=new Object[this.capacity];
	}
	SeqStack(int newcapacity)
	{
		this.arr=new Object[newcapacity];
	}
	
	@Override
	public boolean isEmpty() {
		return this.len==0;
	}

	@Override
	public void push(T item) {
		//1.考虑增容
				if(this.len==this.capacity)
				{
					int newcapacity=capacity*2;
					Object obj[]=new Object[newcapacity];
					for(int i=0;i<this.len;i++)
						obj[i]=this.arr[i];
					this.arr=obj;
					this.capacity=newcapacity;
				}
				this.arr[this.len++]=item;
			}
		
	

	@Override
	public T pop() {
	    assert(!this.isEmpty());
	    T ret=this.peek();
	    this.len--;
		return ret;
	}

	@Override
	public T peek() {
	    assert(!this.isEmpty());
		return (T) this.arr[this.len-1];
	}
}

测试类

public class Test {
	public static void main(String[] args){
	SeqStack<Integer> stack=new SeqStack<>();
	boolean ret2=stack.isEmpty();
	System.out.println(ret2);
	//栈尾插元素
	stack.push(1);
	stack.push(2);
	stack.push(3);
	stack.push(4);
	stack.push(5);
	stack.push(6);
	ret2=stack.isEmpty();
	System.out.println(ret2);
	//取栈顶元素
	int ret=stack.peek();
	System.out.println(ret);
	//栈尾删元素
	System.out.println(stack.len);
	ret=stack.pop();
	System.out.println(ret);
	System.out.println(stack.len);
	
	System.out.println("-------------------------------");
	LinkedQueue<Integer> q=new LinkedQueue<>();
	ret2=q.isEmpty();
	System.out.println(ret2);
	//队列尾插元素
	q.add(1);
	q.add(2);
	q.add(3);
	q.add(4);
	q.add(5);
	q.add(6);
	ret2=q.isEmpty();
	System.out.println(ret2);
	//取队头元素
	int ret1=q.peek();
	System.out.println(ret1);
	//队列头删元素
	q.poll();
	ret1=q.peek();
	System.out.println(ret1);
	}
}