Java实现栈、队列

栈：先进后出

队列：先进先出

栈

1.栈的基本概念

1.什么是栈

栈是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫作栈的顶（top）。

2.对栈的基本操作

进栈：push（相当于插入）

出栈：pop（删除最后插入的元素）

2.用数据来具体实现栈

/**
 * 栈的结构： 
 * 1.boolean push(E data)：入栈 
 * 2.E pop() 出栈 
 * 3.boolean peek() 检视下一个
 * 
 * @author lenovo
 * @param <E>
 *
 */
public class MyStack<T> {
	// size：容器的大小
	// top：指代栈顶下标
	private int size;
	private int top;
	private Object[] data;
	private int len;
	
	/**
	 * 无参构造方法
	 */
	public MyStack() {
		this.size = 0;
		this.top = -1;
		this.data = new Object[10];
		this.len=10;
	}
	/**
	 * 构造方法
	 * @param len 栈的容量
	 */
	public MyStack(int len) {
		this.top = -1;//还未入栈
		this.size = 0;
		if (len<=0) {
			len = 10;
		}
		this.len = len;
		data = new Object[len];
	}
	/**
	 * 入栈
	 * @param t 入栈数据
	 * @return boolean
	 */
	public boolean push(T t) {
		if(size == len) {
			return false;
		}else {
			data[++top] = t;
			size++;
			return true;
		}
	}
	/**
	 * 出栈
	 * @return
	 */
	public T pop() {
		if(size == 0) {
			return null;
		}else {
			T t = (T) data[top--];
			size--;
			return t;
		}
	}
	
	/**
	 * 检视栈顶元素
	 * @return
	 */
	public boolean peek() {
		if (size == 0) {
			return false;
		}else {
			T t =(T)data[top];
			System.out.println(t);
			return true;
		}
	}
	
	/**
	 * 获取栈的大小
	 * @return
	 */
	public int size() {
		return size;
	}
	
	public static void main(String[] args) {
		MyStack<Integer> intStack = new MyStack<>();
		intStack.push(1);
		intStack.push(2);
		intStack.push(3);
		intStack.peek();
		System.out.println(intStack.pop());
		intStack.push(4);
		System.out.println(intStack.pop());
		System.out.println(intStack.pop());
		System.out.println(intStack.pop());
	}
}

//out：
//3
//3
//4
//2
//1

队列

1.什队列的基本概念

1.什么是队列

像栈一样，队列（queue）也是表。然而，使用队列时插入在一端进行而删除则在另一端进行

2.对队列的基本操作

入队：enqueue（在表的末端（队尾rear）插入一个元素）

出队：dequeue（删除并返回在表的开头（队头front）的元素）

3.队列数据个数的计算公式

队列queue：（rear - front+len）%len --计算队列里有多少个数据

2.使用数组来实现队列

/**
 * 队列
 * 1.boolean add(T t) 入队
 * 2.T t offer() 出队
 * 3.boolean peek() 检索队首元素
 * @author lenovo
 *
 */
public class MyQueue<T> {
	private int size;
	private int rear;//队尾
	private int front;//队首
	private Object[] data;
	private int length;
	
	/**
	 * 无参构造
	 */
	public MyQueue(){
		this.size = 0;
		this.rear = -1;//队尾为-1
		this.front = 0;//队首为0
		data = new Object[10];
		this.length = 10;
	}
	/**
	 * 入队
	 * 
	 * @return
	 */
	public boolean add(T t) {
		if(size == length) {
			return false;
		}else {
			rear++;
			data[rear] = t;
			size++;
			return true;
		}
	}
	/*
	 * 出队
	 */
	 public T offer() {
		 if (size == 0) {
			return null;
		}else {
			T t = (T) data[front++];
			if (front == rear) {
				front = 0;
				rear = -1;
			}
			return t;
		}
	 }
	 /**
	  * 检视
	  * @return
	  */
	 public boolean peek() {
		 if (size == 0) {
			return false;
		}else {
			T t = (T) data[front];
			System.out.println(t);
			return true;
		}
	 }
	 public int size() {
		 return this.size;
	 }
	 public static void main(String[] args) {
		MyQueue<Integer> myQueue = new MyQueue<>();
		myQueue.add(1);
		myQueue.add(2);
		myQueue.add(3);
		System.out.println(myQueue.offer());
		myQueue.peek();
		
	}
}

//out：
//1
//2