用java语言写一个简单的栈和队列

一个栈

栈其实相当于线性表，只是少了一些功能（个人理解）

栈的特点：先进先出

栈底层由链表或者数组实现，我个人认为链表更为简单（相对代码实现简单），但是很多人都应用了 数组所以我应用的也是数组

如果是链表当你取数据读数据只需要将丢掉一个结点或者添加一个结点，也不用扩容要移动数据

栈的具体属性和方法

接下来是代码

package Array;


public class MyStack {
private Object [] elementData;
private int size;//数据长度
private int top;//指针
//默认长度为10
public MyStack() {
	elementData=new Object[10];
}
//数组长度至少为1
public MyStack(int size) {
	 if (size < 1)
         throw new IllegalArgumentException("输入有误: "+size);
	elementData=new Object[size];
}
//进栈
public void push(Object obj){
	//此时如果数组容量不够，然后开始扩容，为原来的1.5倍
	if(size()>=elementData.length) {
		change();
	}
	//
	elementData[top++]=obj;
	size++;
}
//出栈
public Object pop() {
	if(size()==0) {
		 throw new IllegalArgumentException("空栈");
	}
	Object obj=elementData[--top];
	elementData[top]=null;
	size--;
	return obj;
}
//扩容
private void  change() {
	int newsize=size()+(size()>>1);
	//若数组长度为1，扩容为原来的2倍
	if(size()==1) {
		newsize=2;
	}
	Object newelementData[]=new Object[newsize];
	//将旧数组中数据移到新数组中
	for(int i=0;i<size();i++) {
		newelementData[i]=elementData[i];
	}
	elementData=newelementData;
}
//获取其长度
public int size() {
	return size;
}
}

队列和栈其实没有什么区别

队列特点：先进先出

我写的队列的属性和方法：

代码

package Array;

public class MyQueue {
private Object  elementData[];
private int front,rear,size;//头指针，尾指针，存储数据长度
//默认长度为10
public MyQueue() {
	elementData=new Object[10];
}
//数组长度至少为1
public MyQueue(int size) {
	if(size<1) {
		throw new IllegalArgumentException("输入有误: "+size);
	}
	elementData=new Object[size];
}
//进队列
public void enqueue(Object obj) {
	//判断是否要扩容
	if(size()>=elementData.length) {
		change();
	}
	//如果尾指针的指向数组尾端，且数组并没有存满
	//则尾指针指向数组0位置
	if(rear>=elementData.length) {
		rear=0;
	}
	size++;
	elementData[rear++]=obj;
}
//扩容
private void change() {
	//扩容为原来的1.5倍
	//如果原来长度为1扩容为原来的2倍
	int newsize=size()+(size()>>1);
	if(size==1) {
		newsize=2;
	}
	//将旧数组的数据移到新数组中
	Object newelementData[]=new Object[newsize];
	for(int i=rear;i<size();i++) {//出队列的第一个元素移到新数组的第0位置
		newelementData[i-rear]=elementData[i];
	}
	for(int i=0;i<=front;i++){
		newelementData[i+(size()-rear)]=elementData[i];
	}
	front=0;
	rear=elementData.length;
	elementData=newelementData;
}
//出队列
public Object deQueue() {
	if(size()<1) {
		throw new IllegalArgumentException("此队列无任何数据");
	}
	Object obj=elementData[front++];
	if(front>=elementData.length) {
		front=0;
	}

	size--;
	return obj;
}
//判断是否为空
public boolean isEmpty() {
	return size()==0;
}
//获取其长度
public int size() {
	return size;
}

}

用两个队列实现一个栈：

特点：队列是先进先出，栈是先进后出

1.需要两个队列a，b

2.存数据时把所有数据都存入a中

3.取数据时，首先将a中取出存入b中只留下一个数据，取出此数据即可

4.在将b中所有数据移除存入a中即可

所应用队列是我个人所写的队列

实现类里的属性和方法

 

代码

package Array;

public class QueueChangStack {
private MyQueue mq1;
private MyQueue mq2;
public QueueChangStack() {
mq1=new MyQueue();
mq2=new MyQueue();
}
public QueueChangStack(int size){
	mq1=new MyQueue(size);
	mq2=new MyQueue(size);
}
//入栈
public void push(Object obj) {
	mq1.enqueue(obj);
}
//出栈
public Object pop() {
	if(mq1.size()<1) {
		 throw new IllegalArgumentException("空栈");
	}
	for(int i=0;i<mq1.size()-1;i++) {
		mq2.enqueue(mq1.deQueue());
	}
	Object obj=mq1.deQueue();
	for(int i=0;i<mq2.size();i++) {
		mq1.enqueue(mq2.deQueue());
	}
	return obj;
}
}

两个栈实现队列

特点：队列是先进先出，栈是先进后出

1.需要两个栈a，b

2.存数据时把所有数据都存入a中

3.取数据时，首先将a中取出存入b中，然后取出b中第一各数据即可

4.在将b中所有数据移除存入a中即可

所应用队列是我个人所写的队列

方法和属性

 

代码

package Array;

public class StackChangeQueue {
private MyStack ms1,ms2;
public StackChangeQueue() {
	ms1=new MyStack();
	ms2=new MyStack();
}
public StackChangeQueue(int size) {
	ms1=new MyStack(size);
	ms2=new MyStack(size);
}
//进队列
public void enqueue(Object obj) {
	//此时栈1数据为空，将栈2中数据
	for(int i=0;i<ms2.size();i++) {
		ms1.push(ms2.pop());
	}
	ms1.push(obj);
}
//出队列
public Object deQueue() {
	if(ms1.size()<1) {
		throw new IllegalArgumentException("此队列无任何数据");
	}
	Object obj;
	//将栈1数据输入到栈2中，然后取出栈2中第一元素即可
	for(int i=0;i<ms1.size();i++) {
		ms2.push(ms1.pop());
	}
	obj=ms2.pop();
	return obj;
}
}

---

 

上边所有内容均是个人所写，有错也在所难免，若博友提出，立马更改