实现一个基本的栈
public class StackX{
int maxSize;
long [] stackArr;
int top;
public StackX(int maxSize){
this.maxSize = maxSize;
top = -1;
stackArr = new long[maxSize];
}
public void push(long value){
stackArr[++top] = value;
}
public long peek(){
return stackArr[top];
}
public long pull(){
return stackArr[top--];
}
public boolean isEmpty(){
return( top == -1);
}
public boolean isFull(){
return (top==maxSize-1);
}
}
实现一个基本的队列
public class Queue{
private int maxSize;
private int nItems;
private long [] queArray;
private int rear;
private int front;
public Queue(int size){
maxSize = size;
nItems = 0;
rear = 0;
front =-1;
queArray = new long[size];
}
//入队
public void insert(long value){
//环绕式处理
if(rear == maxSize -1){
rear = -1;
}
queArray[++rear] = value;
nItems++;
}
public long remove(){
if(!isEmpty()){
long temp = queArray[front];
if(front == maxSize){
front = 0 ;
}
nItems --;
return temp;
}else{
System.out.print("queue is full");
return -1;
}
}
public boolean isEmpty(){
return nItems==0;
}
public boolean isFull(){
return nItems == maxSize;
}
public int size(){
return nItems;
}
public long peekFront(){
return queArray[front];
}
public void display(){
//没有回绕存在
if(rear>=front){
for(int i=front; i<=rear;i++){
System.out.print(queArray[i]+" ");
}
}else{
for(int i = front;i<nItems;i++){
System.out.print(queArray[i]+" ");
}
for(int j = 0;j<=rear;j++){
System.out.print(queArray[i]+" ");
}
}
}
}
当在queue中插入一个数据时,队尾Rear箭头向上移动。当删除一个数据时,队头Front箭头向上移动。这样设计的问题是,队尾Rear很快就会到达数组的末端,
这种情况下,没办法插入新的元素,但是此时其实队列是没有满的。
环绕式处理
为了避免这种情况的发生,可以让队头队尾指针绕回数组开始的位置,这就是循环队列(有时也称“缓冲环“)
队列和栈一样,移除数据和插入数据的时间复杂度都是O(1).
优先级队列
优先级队列是比栈和队列更专用的数据结构,优先级队列有一个队头和队尾,并且也是从队头移除数据,不过在优先级队列中,数据按有序的关键字进行排序。
public class Priority{
private int maxSize;
public long[] queArray;
private int nItems;
public PriorityQ(int s){
maxSize = s;
queArray = new long[maxSize];
nItems =0;
}
public void insert(long items){
int j;
if(nItems ==0){
queArray[nItems++] = items;
}else{
//比items小的需要后移一个位置
for(j= nItems-1;j>=0;j--){
if(items>queArray[j]){
queArray[j+1] = queArray[j];
}else{
break;
}
}
queArray[j+1] =items;
nItems++;
}
}
public long remove(){
long temp = queArray[--nItems];
return temp;
}
//最小的队尾
public long peekMin(){
return queArray[nItems-1];
}
public boolean isEmpty(){
return (nItems == 0);
}
public boolean isFull(){
return (nItems == maxSize);
}
public void inserttwo (long items){
if(!isFull()){
queArray[nItems++] = items;
}
}
public long removetwo(){
long min = queArray[0];
int flag = 0;
//到nItem-1就比较完了
for(int i=0;i<nItems-1;i++){
if(queArray[i]>queArray[i+1]){
flag = i+1;
min = queArray[i+1];
}
}
for(int i = flag;i<nItems-1;i++){
queArray[i] = queArray[i+1];
}
nItems --;
return min;
}
//按插入顺序输出
public void display1(){
for(int i =0;i<queArray.length;i++){
System.out.print(queArray[i]+" ");
}
}
//按优先级,先排序,再输出
public void display2(){
long[] temp = new long[nItems];//临时表
System.arraycopy(queArray, 0, temp, 0, nItems);
int out , in;
for(out = 1;out<nItems;out++){
in = out;
long t =temp[out];
while(in>0 && t < temp[in-1]){
temp[in] = temp[in-1];
in --;
}
temp[in] =t;
}
System.out.println("队列为");
for(int i=0;i<nItems;i++){
System.out.print(temp[i]+" ");
}
System.out.println();
}
}
优先级队列可以不用定义rear和front,优先级队列的rear = nItems -1,
front =0