001 java实现栈与队列

栈

1. 栈概念
     栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

2. 图形解释
   

3. java实现栈结构

package com.ds.lesson02;

import java.util.ArrayList;
import java.util.List;

/**
 * 栈特点：先进后出
 * 
 * 栈所需的变量：
 * 		top：栈顶
 * 		size：栈中元素个数
 * 		length：栈总容量
 * 		list集合：作为栈容器
 * 
 * 实现栈的方法：
 * 		进栈：boolean push(T t)
 * 		出栈：T pop()
 * 		看一下：boolean peek()
 * 		栈中元素个数： int size()
 * 
 * @author Administrator
 *
 */
public class MyStack<T> {
	private int top;    // 栈顶，表示栈顶元素的下标
	private int size;    // 栈中元素个数
	private int length;   //栈的总容量
	private List<T> listStack = new ArrayList<T>();     //作为栈容器
	/**
	 * 无参构造方法
	 */
	public MyStack() {
		this.top = -1;
		this.size = 0;
		this.length = 10;
	}
	
	/**
	 * 含参构造:设置栈总容量
	 * @param length  栈的总容量
	 */
	public MyStack(int length) {
		super();
		this.top = -1;
		this.size = 0;
		this.length = length;
		if(length <= 0){
			this.length = 10;
		}
	}
	
	/**
	 * 入栈方法
	 * @param t 入栈数据
	 * @return boolean
	 */
	public boolean push(T t){
		//判断栈满
		if(size == length){
			return false;
		}
		else{
			top++;
			listStack.add(t);
			size++;
			return true;
		}
	}
	
	/**
	 * 出栈方法
	 * @return T 栈顶元素
	 */
	public T pop(){
		//判断栈空
		if(size == 0){
			return null;
		}
		else{
			T t = listStack.get(top);
			top--;
			size--;
			return t;
		}
	}
	
	/**
	 * 查看栈顶元素
	 * @return boolean
	 */
	public boolean peek(){
		//判断栈是否为空
		if(size == 0){
			return false;
		}
		else{
			T t = listStack.get(top);
			System.out.println(t);
			return true;
		}
	}
	
	/**
	 * 查看栈中元素个数
	 * @return int 栈中元素个数
	 */
	public int size(){
		
		return size;
	}
	public static void main(String[] args) {
		
		MyStack<Integer> myStack = new MyStack<>();
		//进栈
		System.out.println("=============进栈===============");
		myStack.push(1);
		myStack.push(2);
		myStack.push(3);
		System.out.println("栈内元素：" + myStack.size());
		//看一下栈顶
		System.out.print("栈顶：");
		myStack.peek();
		
		//出栈
		System.out.println("=============出栈===============");
		System.out.println("出栈：" + myStack.pop());
		System.out.println("栈内元素：" + myStack.size());
		//看一下栈顶
		System.out.print("栈顶：");
		myStack.peek();
	}
}

4. 运行结果
   

队列

1. 队列概念
     队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头
2. 图形解释
   
3. java实现队列结构

package com.ds.lesson02;

import java.util.ArrayList;
import java.util.List;

/**
 * 队列特点：先进先出
 * 
 * 队列所需变量：
 * 		front：队首，表示队首下标
 * 		rear：队尾，表示队尾下标
 * 		size：队列中元素个数
 * 		length：队列总容量
 * 		list：最为队列容器
 * 
 * 实现队列的方法：
 * 		入队：boolean add(T t)
 * 		出队： T offer()
 * 		查看队首： boolean peek()
 * 		队内元素个数：int size()
 * 
 * @author Administrator
 *
 * @param <T>
 */
public class MyQueue<T> {
	private int front;
	private int rear;
	private int length;
	private int size;
	private List<T> queue = new ArrayList<>();
	
	/**
	 * 无参构造
	 */
	public MyQueue() {
		this.front = 0;
		this.rear = -1;
		this.size = 0;
		this.length = 10;
	}
	
	/**
	 * 入队方法
	 * @param t 入队元素
	 * @return boolean
	 */
	public boolean add(T t){
		//判断队满
		if(size == length){
			return false;
		}
		else{
			rear++;               //队尾下标加1
			queue.add(rear, t);   //入队到队尾
			size++;               //队中元素个数加1
			return true;
		}
	}
	
	/**
	 *出队方法
	 * @return t 出队元素
	 */
	public T offer(){
		//判断队空
		if(size == 0){
			return null;
		}
		else{
			T t = queue.get(front);   // 获取队首元素
			// 队尾队首下标相同时，出队后队为空，队变量回到初始状态
			if(front == rear){        
				front = 0;
				rear = -1;
				size = 0;
				return t;
			}
			front++;
			size--;
			return t;
		}
	}
	
	/**
	 * 查看队首元素
	 * @return boolean 
	 */
	public boolean peek(){
		//判断队空
		if(size == 0){
			return false;
		}
		else{
			T t = queue.get(front);
			System.out.println(t);
			return true;
		}	
	}
	
	/**
	 *  获取队内元素个数
	 * @return int 
	 */
	public int size(){
		return size;
	}
	public static void main(String[] args) {
		MyQueue<String> myQueue = new MyQueue<>();
		//入队
		System.out.println("==============入队==============");
		myQueue.add("a");
		myQueue.add("b");
		myQueue.add("c");
		System.out.println("队元素个数：" + myQueue.size());
		System.out.print("队首：");
		myQueue.peek();
		
		System.out.println("==============出队==============");
		System.out.println("出队元素：" + myQueue.offer());
		System.out.println("队元素个数：" + myQueue.size());
		System.out.print("队首：");
		myQueue.peek();
	}

}

4. 运行结果