Java数据结构与算法-栈和队列

public class MyStack {
    private int[] array;
    private int maxSize;
    private int top;
     
    public MyStack(int size){
        this.maxSize = size;
        array = new int[size];
        top = -1;
    }
     
    //压入数据
    public void push(int value){
        if(top < maxSize-1){
            array[++top] = value;
        }
    }
     
    //弹出栈顶数据
    public int pop(){
        return array[top--];
    }
     
    //访问栈顶数据
    public int peek(){
        return array[top];
    }
     
    //判断栈是否为空
    public boolean isEmpty(){
        return (top == -1);
    }
     
    //判断栈是否满了
    public boolean isFull(){
        return (top == maxSize-1);
    }

}

package stack.test;

import java.util.Arrays;
import java.util.EmptyStackException;

public class ArrayStack {

	// 存储元素的数组,声明为Object类型能存储任意类型的数据
	private Object[] elementData;
	// 指向栈顶的指针
	private int top;
	// 栈的总容量
	private int size;

	// 默认构造一个容量为10的栈
	public ArrayStack() {
		this.elementData = new Object[10];
		this.top = -1;
		this.size = 10;
	}

	public ArrayStack(int initialCapacity) {
		if (initialCapacity < 0) {
			throw new IllegalArgumentException("栈初始容量不能小于0: " + initialCapacity);
		}
		this.elementData = new Object[initialCapacity];
		this.top = -1;
		this.size = initialCapacity;
	}

	// 压入元素
	public Object push(Object item) {
		// 是否需要扩容
		isGrow(top + 1);
		elementData[++top] = item;
		return item;
	}

	// 弹出栈顶元素
	public Object pop() {
		Object obj = peek();
		remove(top);
		return obj;
	}

	// 获取栈顶元素
	public Object peek() {
		if (top == -1) {
			throw new EmptyStackException();
		}
		return elementData[top];
	}

	// 判断栈是否为空
	public boolean isEmpty() {
		return (top == -1);
	}

	// 删除栈顶元素
	public void remove(int top) {
		// 栈顶元素置为null
		elementData[top] = null;
		this.top--;
	}

	/**
	 * 是否需要扩容，如果需要，则扩大一倍并返回true，不需要则返回false
	 * 
	 * @param minCapacity
	 * @return
	 */
	public boolean isGrow(int minCapacity) {
		int oldCapacity = size;
		// 如果当前元素压入栈之后总容量大于前面定义的容量，则需要扩容
		if (minCapacity >= oldCapacity) {
			// 定义扩大之后栈的总容量
			int newCapacity = 0;
			// 栈容量扩大两倍(左移一位)看是否超过int类型所表示的最大范围
			if ((oldCapacity << 1) - Integer.MAX_VALUE > 0) {
				newCapacity = Integer.MAX_VALUE;
			} else {
				newCapacity = (oldCapacity << 1);// 左移一位，相当于*2
			}
			this.size = newCapacity;
			elementData = Arrays.copyOf(elementData, size);
			return true;
		} else {
			return false;
		}
	}
　　　　//测试字符串输入“drive”
	public static void main(String[] args) {
		String testString = "drive";
		ArrayStack stack = new ArrayStack(10);
		char[] cc = testString.toCharArray();
		for (char c : cc) {
			stack.push(c);
		}
		while (!stack.isEmpty()) {
			System.out.print(stack.pop());
		}
	}

}

//分隔符匹配
//遇到左边分隔符了就push进栈，遇到右边分隔符了就pop出栈，看出栈的分隔符是否和这个有分隔符匹配
@Test
public void testMatch(){
    ArrayStack stack = new ArrayStack(3);
    String str = "12<a[b{c}]>";
    char[] cha = str.toCharArray();
    for(char c : cha){
        switch (c) {
        case ‘{‘:
        case ‘[‘:
        case ‘<‘:
            stack.push(c);
            break;
        case ‘}‘:
        case ‘]‘:
        case ‘>‘:
            if(!stack.isEmpty()){
                char ch = stack.pop().toString().toCharArray()[0];
                if(c==‘}‘ && ch != ‘{‘
                    || c==‘]‘ && ch != ‘[‘
                    || c==‘)‘ && ch != ‘(‘){
                    System.out.println("Error:"+ch+"-"+c);
                }
            }
            break;
        default:
            break;
        }
    }
}

public class MyQueue {
    private Object[] queArray;
    //队列总大小
    private int maxSize;
    //前端
    private int front;
    //后端
    private int rear;
    //队列中元素的实际数目
    private int nItems;
     
    public MyQueue(int s){
        maxSize = s;
        queArray = new Object[maxSize];
        front = 0;
        rear = -1;
        nItems = 0;
    }
     
    //队列中新增数据
    public void insert (int value) {
        if (!isfull()) {
            if (rear == maxsize - 1) {
                   rear = -1;
            }
            quearray[++rear] = value;
            items++;
        }
        else
            System.out.println("队列已经满了.");
        }
     
    //移除数据
    public Object remove(){
        Object removeValue = null ;
        if(!isEmpty()){
            removeValue = queArray[front];
            queArray[front] = null;
            front++;
            if(front == maxSize){
                front = 0;
            }
            nItems--;
            return removeValue;
        }
        return removeValue;
    }
     
    //查看队头数据
    public Object peekFront(){
        return queArray[front];
    }
     
     
    //判断队列是否满了
    public boolean isFull(){
        return (nItems == maxSize);
    }
     
    //判断队列是否为空
    public boolean isEmpty(){
        return (nItems ==0);
    }
     
    //返回队列的大小
    public int getSize(){
        return nItems;
    }
     
}                

public class PriorityQue {
    private int maxSize;
    private int[] priQueArray;
    private int nItems;
     
    public PriorityQue(int s){
        maxSize = s;
        priQueArray = new int[maxSize];
        nItems = 0;
    }
     
    //插入数据
    public void insert(int value){
        int j;
        if(nItems == 0){
            priQueArray[nItems++] = value;
        }else{
            j = nItems -1;
            //选择的排序方法是插入排序，按照从大到小的顺序排列，越小的越在队列的顶端
            while(j >=0 && value > priQueArray[j]){
                priQueArray[j+1] = priQueArray[j];
                j--;
            }
            priQueArray[j+1] = value;
            nItems++;
        }
    }
     
    //移除数据,由于是按照大小排序的，所以移除数据我们指针向下移动
    //被移除的地方由于是int类型的，不能设置为null，这里的做法是设置为 -1
    public int remove(){
        int k = nItems -1;
        int value = priQueArray[k];
        priQueArray[k] = -1;//-1表示这个位置的数据被移除了
        nItems--;
        return value;
    }
     
    //查看优先级最高的元素
    public int peekMin(){
        return priQueArray[nItems-1];
    }
     
    //判断是否为空
    public boolean isEmpty(){
        return (nItems == 0);
    }
     
    //判断是否满了
    public boolean isFull(){
        return (nItems == maxSize);
    }
 
}