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

重点：

这里只是模拟栈的结构，准确点来说只是模拟栈的最基础结构，真正的栈基本都是计算机系统管理的，涉及到寄存器方面的知识

栈有栈顶和栈底之分，还是那句老话，先进后出，想象成一个箱子，先放进去的压在箱底，最后才能拿出来，箱子也有装满的时候，所以慎用递归，内存不足的情况下，方法调用的深度和变量的使用也得注意，不然会爆帧，不过现在的计算机比较难遇到咯~~

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

重点:

个人觉得搞清楚队头（head）和队尾（tail）指向的元素就行了，整个过程就像转盘一样，队头和队尾指向的位置不停地轮转

至于实际用途就不知道在哪里有用到了，功力还不够深，学识尚浅，还请各位前辈和有识之士指教！