数据结构-栈和队列

本次学习主题是栈和队列。
栈和队列应该是数据结构中非常基本的结构单元，一般作为其他结构的组成单元或者算法中。
和数组的随机访问特性不同，栈的特点是后进先出(LIFO)，队列的特点是先进先出(FIFO)。
数组应该是非常基本的数据结构单元了，所以数组类型非常直观，就是一个物理和逻辑结构都连续的空间。而栈和队列就更加抽象一些，一般通过接口定义其特性，然后可以通过很多方式来实现。
这次的学习内容依然很基础，主要内容为栈、队列、优先级队列。都是通过数组实现(也可以通过链表,后面会有学习)。其中优先级队列就是在队列的基础上，不是直接将数据插入表尾，而是根据优先级插入到同优先级数列的最后，保证插入操作完成后队列仍然是优先级有序的。
1-栈代码如下：

public class StackX {
    private char[] ar;
    private int size;

    public StackX(int s) {
        ar = new char[s];
        size = 0;
    }

    public void push(char v) {
        if (isFull()) {
            return;
        }

        ar[size++] = v;
    }

    public char pop() {
        if (isEmpty()) {
            return 0;
        }
        return ar[--size];
    }

    public char peek() {
        return ar[size - 1];
    }

    public void displayStack() {
        System.out.println("{");
        for (int i = 0; i <= size; i++) {
            System.out.println("" + ar[i] + ",");
        }
        System.out.println("}");
    }

    public boolean isEmpty() {
        // System.out.println("the stack is empty");
        return size == 0;
    }

    public boolean isFull() {
        // System.out.println("the stack is full");
        return size == ar.length;
    }

}

检测字符串分隔符代码如下：

//分隔符匹配
public class BracketChecker {
    private String checkStr;

    public BracketChecker(String s) {
        checkStr = s;
    }

    public boolean check() {
        int length = checkStr.length();
        StackX sx = new StackX(length);
        for (int i = 0; i < length; i++) {
            char temp = checkStr.charAt(i);
            switch (temp) {
            case '{':
            case '[':
            case '(': {
                sx.push(temp);
                break;
            }
            case '}':
            case ']':
            case ')': {
                if (!sx.isEmpty()) {
                    if ((temp == '}' && sx.pop() != '{') || (temp == ']' && sx.pop() != '[')
                            || (temp == ')' && sx.pop() != '(')) {
                        System.out.println("error char at " + temp);
                        return false;
                    }
                } else {
                    System.out.println("error char at " + temp);
                    return false;
                }
            }
            default:
                break;

            }

        }
        if (sx.isEmpty()) {
            return true;
        }

        return false;
    }
}

2-队列代码实现：因为队列和栈基本差不多，只是插入删除有些区别，这里只列出主要部分。

public class QueueX {
    private int MaxSize;
    private long[] ar;
    private int front;
    private int rear;
    private int count;// 当前数组数量，也可以不用，通过front 和 rear来计算

    public void insert(long value) {
        if (rear == MaxSize - 1) {
            rear = -1;// 循环队列，从数组最后跑到最前面
        }
        ar[++rear] = value;
        count++;
    }

    public long remove() {
        long temp = ar[front++];
        if (front == MaxSize) {
            front = 0;
        }
        count--;
        return temp;
    }

}

3-优先级队列与队列基本相同，主要区别就是插入时是否有序，因此只写出优先级队列的插入方法：

public void proInsert(long value) {
        if (0 == count) {
            ar[count++] = value;
        } else {
            int j;
            for (j = count - 1; j >= 0; j--) {
                if (value > ar[j]) {
                    ar[j + 1] = ar[j];
                } else {
                    break;
                }
            }
            ar[j + 1] = value;
            count++;

        }
    }

栈和队列可以用于表达式解析，中缀转后缀等应用，一般都是做辅助。
Java的集合框架应该去学习一下，网上类似的资料已经很多，应该去研究一下。