栈和队列

2015年7月28日09:31:46 发表评论 5 views

##栈

栈只允许访问一个数据项:即最后插入的数据。溢出这个数据才能访问倒数第二个插入的数据项。它是一种"后进先出"的数据结构。

栈最基本的操作是出栈(Pop)、入栈(Push),还有其他扩展操作,如查看栈顶元素,判断栈是否为空、是否已满,读取栈的大小等。

/**
 * 栈是先进后出
 * 只能访问栈顶的数据
 * @author dream
 *
 */
/**
 * 基于数组来实现栈的基本操作
 * 数据项入栈和出栈的时间复杂度均为O(1)
 * @author dream
 *
 */
public class ArrayStack {
	private long[] a;
	private int size;   //栈数组的大小
	private int top;   //栈顶
	public ArrayStack(int maxSize){
		this.size = maxSize;
		this.a = new long[size];
		this.top = -1;   //表示空栈
	}
	public void push(long value){   //入栈
		if(isFull()){
			System.out.println("栈已满!");
			return;
		}
		a[++top] = value;
	}
	public long peek(){   //返回栈顶内容,但不删除
		if(isEmpty()){
			System.out.println("栈中没有数据");
			return 0;
		}
		return a[top];
	}
	public long pop(){   //弹出栈顶内容
		if(isEmpty()){
			System.out.println("栈中没有数据!");
			return 0;
		}
		return a[top--];
	}
	public int size(){
		return top + 1;
	}
	/**
	 * 判断是否满了
	 * @return
	 */
	public boolean isFull(){
		return (top == size - 1);
	}
	/**
	 * 是否为空
	 * @return
	 */
	public boolean isEmpty(){
		return (top == -1);
	}
	public void display(){
		for (int i = top; i >= 0; i--) {
			System.out.println(a[i] + " ");
		}
		System.out.println("");
	}
	
}

##队列

依然使用数组作为底层容器来实现一个队列的封装

/**
 * 队列也可以用数组来实现,不过这里有个问题,当数组下标满了后就不能再添加了,
 * 但是数组前面由于已经删除队列头的数据了,导致空。所以队列我们可以用循环数组来实现,
 * @author dream
 *
 */
public class RoundQueue {
	private long[] a;
	private int size;     //数组大小
	private int nItems;    //实际存储数量
	private int front;     //头
	private int rear;       //尾
	public RoundQueue(int maxSize){
		this.size = maxSize;
		a = new long[size];
		front = 0;
		rear = -1;
		nItems = 0;
	}
	public void insert(long value){
		if(isFull()){
			System.out.println("队列已满");
			return;
		}
		rear = ++rear % size;
		a[rear] = value;  //尾指针满了就循环到0处,这句相当于下面注释内容
		nItems++;
	}
	public long remove(){
		if(isEmpty()){
			System.out.println("队列为空!");
			return 0;
		}
		nItems--;
		front = front % size;
		return a[front++];
	}
	public void display(){
		if(isEmpty()){
			System.out.println("队列为空!");
			return;
		}
		int item = front;
		for(int i = 0;i < nItems; i++){
			System.out.println(a[item++ % size] + " ");
		}
		System.out.println("");
	}
	public long peek(){
		if(isEmpty()){
			System.out.println("队列为空!");
			return 0;
		}
		return a[front];
	}
	public boolean isFull(){
		return (nItems == size);
	}
	public boolean isEmpty(){
		return (nItems == 0);
	}
	public int size(){
		return nItems;
	}	
}

和栈一样,队列中插入数据项和删除数据项的时间复杂度均为O(1)

还有个优先级队列,优先级队列是比栈和队列更专用的数据结构。优先级队列与上面普通的队列相比,主要区别在于队列中的元素是有序的,关键字最小(或者最大)的数据项总在队头。数据项插入的时候会按照顺序插入到合适的位置以确保队列的顺序。优先级队列的内部实现可以用数组或者一种特别的树——堆来实现。这里用数组实现优先级队列。

public class PriorityQueue {
   private long[] a;
   private int size;
   private int nItems;  //元素个数
   public PriorityQueue(int maxSize){
   	size = maxSize;
   	nItems = 0;
   	a = new long[size];
   }
   public void insert(long value){
   	if(isFull()){
   		System.out.println("队列已满!");
   		return;
   	}
   	int j;
   	if(nItems == 0){  //空队列直接添加
   		a[nItems++] = value;
   	}else {
   		//将数组中的数字依照下标按照从大到小排列
   		for(j=nItems-1; j>=0; j--){
   			if(value > a[j]){  
                   a[j+1] = a[j];  
               }  
               else {  
                   break;  
               } 
   		}
   		a[j+1] = value;
   		nItems++;
   	}
   }
   public long remove(){
   	if(isFull()){
   		System.out.println("队列为空!");
   		return 0;
   	}
   	return a[--nItems];
   }
   public long peekMin(){
   	return a[nItems - 1];
   }
   public boolean isFull(){
   	return (nItems == size);
   }
   public boolean isEmpty(){
   	return (nItems == 0);
   }
   public int size(){
   	return nItems;
   }
   public void display(){
   	for(int i = nItems - 1;i >= 0; i--){
   		System.out.println(a[i] + " ");
   	}
   	System.out.println(" ");
   }
}

优先级队列中,插入操作需要O(N)的时间,而删除操作则需要O(1)的时间。

  • yiisaa
  • 这是我的微信扫一扫
  • weinxin
  • zhengweiqiangcom
  • 我的微信公众号扫一扫
  • weinxin

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: