数据结构

栈

用数组的方式实现

public class ArrayStack {
    private long[] array;  //数组方式实现
    private int top;  //栈顶
    private int size;  //栈的容量

    public ArrayStack() {  //初始化
        this(10);
    }

    public ArrayStack(int maxsize) {
        if (maxsize < 0) {
            throw new RuntimeException("栈初始化失败！");
        }
        size = maxsize;
        array = new long[size];
        top = -1;
    }

    public long peek() {  //返回栈顶元素
        if (isEmpty()) {
            throw new RuntimeException("栈为空！");
        } else {
            System.out.println("栈顶元素为：" + array[top]);
            return array[top];
        }
    }

    public void push(long elem) {  //入栈
        if (isFull()) {
            throw new RuntimeException("栈已满！");
        }
        array[++top] = elem;
        System.out.println("栈中成功插入元素，该元素为：" + elem);
    }

    public void pop() {  //出栈
        if (isEmpty()) {
            throw new RuntimeException("栈为空！");
        }
        System.out.println("栈中元素成功被删除，该元素为：" + array[top]);
        top--;

    }

    public int size() {  //栈内元素个数
        return size;
    }

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

    public boolean isFull() {  //栈是否已满
        return top == size - 1;
    }
    
}

队列

普通队列

存在假溢出问题，可以使用循环队列

public class ArrayQueue {
    private long[] array;
    private int size;
    private int front;
    private int rear;

    public ArrayQueue() {
        this(10);
    }

    public ArrayQueue(int maxsize) {
        size = maxsize;
        array = new long[size];
        front = 0;
        rear = -1;
    }

    public void enqueue(long elem) {
        if (isFull()) {
            throw new RuntimeException("队列已满！");
        }
        array[++rear] = elem;
    }

    public void dequeue() {
        if (isEmpty()) {
            throw new RuntimeException("队列为空！");
        }
        front++;
    }

    public String show() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("[");
        for (int i = front; i <= rear; i++) {
            stringBuilder.append(array[i]);
            if (i != rear) {
                stringBuilder.append(",");
            }
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }

    public int size() {
        return size;
    }

    public boolean isFull() {
        return size == rear + 1;
    }

    public boolean isEmpty() {
        return rear == -1;
    }
    
}

循环队列

public class ArrayRoundedQueue {
    private long[] array;
    private int size;  //队列的容量
    private int pracSize;  //已使用的容量
    private int front;  //队头
    private int rear;  //队尾

    public ArrayRoundedQueue() {
        this(10);
    }

    public ArrayRoundedQueue(int maxsize) {
        size = maxsize;
        pracSize = 0；
        array = new long[size];
        front = 0;
        rear = -1;
    }

    public void enqueue(long elem) {  //入队
        if (isFull()) {
            throw new RuntimeException("队列已满！");
        }
        pracSize++;
        rear = ++rear % size;
        array[rear] = elem;
    }

    public void dequeue() {  //出队
        if (isEmpty()) {
            throw new RuntimeException("队列为空！");
        }
        pracSize--;
        front++;
    }

    public String show() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("[");
        if (front <= rear) {
            for (int i = front; i <= rear; i++) {
                stringBuilder.append(array[i]);
                if (i != rear) {
                    stringBuilder.append(",");
                }
            }
        } else {
            for (int i = front; i < size; i++) {
                stringBuilder.append(array[i]).append(",");
            }
            for (int i = 0; i <= rear; i++) {
                stringBuilder.append(array[i]);
                if (i != rear) {
                    stringBuilder.append(",");
                }
            }
        }

        stringBuilder.append("]");
        return stringBuilder.toString();
    }

    public int size() {
        return size;
    }

    public boolean isFull() {
        return size == pracSize;
    }

    public boolean isEmpty() {
        return pracSize == 0;
    }

}

排序

冒泡排序

使用flag进行优化

    public static int[] bubbleSort(int[] array) {
        int temp;
        for (int i = 0; i < array.length - 1; i++) {
            boolean flag = true;  //进行优化
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    temp = array[i];  //数组元素进行交换
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = false;  //一轮循环下来，没有发生交换，则已经排序好，无需再排序
                }
            }
            if (flag) {
                break;
            }
        }
        return array;
    }