java数据结构和算法-2,栈和队列

	在Java的世界里讨论的最多的应该是栈和队才对吧！但这里是数据结构和算法，并不是Java虚拟机。

废话不说，码上见！

1、栈

public class StackTest {
	private int[] arr;//用数组模拟栈的结构
	private int top;//栈顶的位置
	
	public StackTest(){
		arr = new int[10];
		top = -1;
	}
	
	//可以自定义栈的大小
	public StackTest(int maxSize){
		arr = new int[maxSize];
		top = -1;
	}
	
	//入栈
	public void push(int value){
		arr[++top] = value;
	}
	
	//出栈
	public int pop(){
		return arr[top--];
	}
	
	//获取栈顶元素
	public int top(){
		return arr[top];
	}
	
	public static void main(String[] args) {
		StackTest s = new StackTest(3);
		s.push(12);
		s.push(15);
		s.push(0);
		System.out.println(s.top());
	}
	
}

输出结果：

0

重点：

1. 这里只是模拟栈的结构，准确点来说只是模拟栈的最基础结构，真正的栈基本都是计算机系统管理的，涉及到寄存器方面的知识
2. 栈有栈顶和栈底之分，还是那句老话，先进后出，想象成一个箱子，先放进去的压在箱底，最后才能拿出来，箱子也有装满的时候，所以慎用递归，内存不足的情况下，方法调用的深度和变量的使用也得注意，不然会爆帧，不过现在的计算机比较难遇到咯~~

2、队列

public class QueueTest {
	private int[] arr;//同样用数组模拟队列
	private int head = 0;//队列头部位置，首元素索引为0
	private int tail = -1;//队列尾部，现在没元素，先给-1
	
	public QueueTest(){
		arr = new int[10];
	}
	
	public QueueTest(int maxSize){
		arr = new int[maxSize];
	}
	
	//入队，从前往后添加元素
	public void in(int element){
		arr[++tail] = element;
	}
	
	//出队，从前往后输出元素
	public int out(){
		return arr[head--];
	}
}

队列的main的方法就不写了，同样的道理

重点（feihua）：

1. 和栈相反，先进先出，想象成一个隧道，车子一辆一辆通过
2. 队列的使用我们用的较多的是多线程，不过平时用框架的话基本都帮我们处理好了而已

3、循环队列

public class CycleQueueTest {
	private int elements = 0;//有效元素个数
	private int[] arr;//声明一个数组，用于存放队列的元素
	private int head = 0;//队头位置
	private int tail = -1;//队尾位置
	
	public CycleQueueTest(){
		arr = new int[6];
	}
	
	public CycleQueueTest(int maxSize){
		arr = new int[maxSize];
	}
	
	//入队
	public int in(int element){
		int h = 0;//用于输出队头元素
		if (isFull()) {//如果数组满了，则开始队列的循环
			if (head == arr.length) {//如果队头循环一轮结束后回到原来位置，那么这里也还原队头和队尾的位置指向
				head = 0;
				tail = -1;
				arr[++tail] = element;
				h = arr[head];
			}else{	
			/*
			 * 如果一轮没有循环结束，则插入一个新元素的时候，队头和队尾都向前移一个单元，
			 * 为什么前移一个单元？其实如果不移的话，你也可以重新为数组排序，把数组的每
			 * 个元素统一往后移一个单元，然后在数组的第一个元素的位置替换新入队的数就行
			 */
				h = arr[head];
				head++;
				tail = head-1;
				arr[tail] = element;
			}
			
		}else{//这里是第一轮数组还没满的时候执行的操作
			arr[++tail] = element;
			elements ++;
			h = arr[head];
		}
		return h;
	}
	
	//出队
	public int out(){  
		return arr[head--];
	}
	
	//判断队列是否满了
	public boolean isFull(){
		return arr.length == elements;
	}
	
	public static void main(String[] args) {
		CycleQueueTest c = new CycleQueueTest();
		c.in(1);
		c.in(2);
		c.in(3);
		c.in(4);
		c.in(5);
		c.in(1);
		c.in(2);
		c.in(3);
		c.in(4);
		c.in(5);
		c.in(8);
		c.in(9);
		c.in(10);
		for (int i = 0; i < c.arr.length; i++) {
			System.out.println(c.arr[i]);
		}
	}
}

输出结果：

10
3
4
5
8
9

重点:

1. 个人觉得搞清楚队头（head）和队尾（tail）指向的元素就行了，整个过程就像转盘一样，队头和队尾指向的位置不停地轮转
2. 至于实际用途就不知道在哪里有用到了，功力还不够深，学识尚浅，还请各位前辈和有识之士指教！