java数据结构 （栈和列队）

public class MyStack { 
    //底层实现是一个数组 
    private long[] arr; 
    private int top; 

    /** 
     * 默认的构造方法 
     */ 
    public MyStack() { 
        arr = new long[10]; 
        top = -1; 
    } 

    /** 
     * 带参数构造方法，参数为数组初始化大小 
     */ 
    public MyStack(int maxsize) { 
        arr = new long[maxsize]; 
        top = -1; 
    } 

    /** 
     * 添加数据 
     */ 
    public void push(int value) { 
        arr[++top] = value; 
    } 

    /** 
     * 移除数据 
     */ 
    public long pop() { 
        return arr[top--]; 
    } 

    /** 
     * 查看数据 
     */ 
    public long peek() { 
        return arr[top]; 
    } 

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

    /** 
     * 判断是否满了 
     */ 
    public boolean isFull() { 
        return top == arr.length - 1; 
    } 
}

测试

public class TestMyStack { 
    public static void main(String[] args) { 
        MyStack ms = new MyStack(4); 
        ms.push(23); 
        ms.push(12); 
        ms.push(1); 
        ms.push(90); 
        System.out.println(ms.isEmpty()); 
        System.out.println(ms.isFull()); 

        System.out.println(ms.peek()); 
        System.out.println(ms.peek()); 

        while(!ms.isEmpty()) { 
            System.out.print(ms.pop() + ","); 
        } 

        System.out.println(ms.isEmpty()); 
        System.out.println(ms.isFull()); 
    } 
}

/* 
 * 列队类 
 */ 
public class MyQueue { 
    //底层使用数组 
    private long[] arr; 
    //有效数据的大小 
    private int elements; 
    //队头 
    private int front; 
    //队尾 
    private int end; 

    /** 
     * 默认构造方法 
     */ 
    public MyQueue() { 
        arr = new long[10]; 
        elements = 0; 
        front = 0; 
        end = -1; 
    } 

    /** 
     * 带参数的构造方法，参数为数组的大小 
     */ 
    public MyQueue(int maxsize) { 
        arr = new long[maxsize]; 
        elements = 0; 
        front = 0; 
        end = -1; 
    } 

    /** 
     * 添加数据,从队尾插入 
     */ 
    public void insert(long value) { 
        arr[++end] = value; 
        elements++; 
    } 

    /** 
     * 删除数据，从队头删除 
     */ 
    public long remove() { 
        elements--; 
        return arr[front++]; 
    } 

    /** 
     * 查看数据，从队头查看 
     */ 
    public long peek() { 
        return arr[front]; 
    } 

    /** 
     * 判断是否为空 
     */ 
    public boolean isEmpty() { 
        return elements == 0; 
    } 

    /** 
     * 判断是否满了 
     */ 
    public boolean isFull() { 
        return elements == arr.length; 
    } 
}

循环列队

/* 
 * 列队类 
 */ 
public class MyCycleQueue { 
    //底层使用数组 
    private long[] arr; 
    //有效数据的大小 
    private int elements; 
    //队头 
    private int front; 
    //队尾 
    private int end; 

    /** 
     * 默认构造方法 
     */ 
    public MyCycleQueue() { 
        arr = new long[10]; 
        elements = 0; 
        front = 0; 
        end = -1; 
    } 

    /** 
     * 带参数的构造方法，参数为数组的大小 
     */ 
    public MyCycleQueue(int maxsize) { 
        arr = new long[maxsize]; 
        elements = 0; 
        front = 0; 
        end = -1; 
    } 

    /** 
     * 添加数据,从队尾插入 
     */ 
    public void insert(long value) { 
        if(end == arr.length - 1) { 
            end = -1; 
        } 
        arr[++end] = value; 
        elements++; 
    } 

    /** 
     * 删除数据，从队头删除 
     */ 
    public long remove() { 
        long value = arr[front++]; 
        if(front == arr.length) { 
            front = 0; 
        } 
        elements--; 
        return value; 
    } 

    /** 
     * 查看数据，从队头查看 
     */ 
    public long peek() { 
        return arr[front]; 
    } 

    /** 
     * 判断是否为空 
     */ 
    public boolean isEmpty() { 
        return elements == 0; 
    } 

    /** 
     * 判断是否满了 
     */ 
    public boolean isFull() { 
        return elements == arr.length; 
    } 
}

public class TestMyQueue { 
    public static void main(String[] args) { 
        MyCycleQueue mq = new MyCycleQueue(4); 
        mq.insert(23); 
        mq.insert(45); 
        mq.insert(13); 
        mq.insert(1); 

        System.out.println(mq.isFull()); 
        System.out.println(mq.isEmpty()); 

        System.out.println(mq.peek()); 
        System.out.println(mq.peek()); 

        while (!mq.isEmpty()) { 
            System.out.print(mq.remove() + " "); 
        } 
        System.out.println(); 

        mq.insert(23); 
        mq.insert(45); 
        mq.insert(13); 
        mq.insert(1); 

        while (!mq.isEmpty()) { 
            System.out.print(mq.remove() + " "); 
        } 
    } 
}