用数组实现栈和队列

本篇文章是模拟LinkedList实现其中的：添加，取值，入队，出队，入栈，出栈

1.动态数组的实现

package com.sxt.test.java;

public class Array {
    protected Object[] arrays = new Object[0];
    protected Object[] arrays2=null;
　　
　　//每增加一个元素，就新建一个比原来长度+1的数组，
   //把原来数组的数据都放入新的数组，最后把新加的数据添到最后
　　//原数组置空    
    public void add(Object o) {

        if(arrays!=null && arrays2==null) {
            arrays2 = new Object[arrays.length+1];
            for(int i=0;i<arrays.length;i++) {
                arrays2[i] = arrays[i];
            }
            arrays2[arrays.length] = o;
            arrays = null;
            return;
        }
        
        if(arrays==null && arrays2!=null) {
            arrays = new Object[arrays2.length+1];
            for(int i=0;i<arrays2.length;i++) {
                arrays[i] = arrays2[i];
            }
            arrays[arrays2.length] = o;
            arrays2 = null;
            return;
        }

    }
    //取数据时，两个数组必定有一个为空，一个有数据
    public Object get(int index) {
        Object o = null;
        try {
            if(arrays!=null) {
                o = arrays[index];
            }
            if(arrays2!=null) {
                o = arrays[index];
            }
        }catch(Exception e) {
            throw new RuntimeException("出错了..",e);
        }
        return o;
    }
    public int length() {
        int length = 0;
        if(arrays!=null) {
            length = arrays.length;
        }else
        if(arrays2!=null) {
            length = arrays2.length;
        }
        return length;
    }
}

2.队列的实现

package com.sxt.test.java;

public class Queue extends Array{

    
    /**
     * 入队
     * */
    public void add(Object o) {
        super.add(o);
    }
    /**
     * 出队
　　　* 两个数组必定一个有数据，一个为空
　　　* 取出第一个数据，然后新建一个比原来长度-1的数组
     * 从后往前，把数据放入新数组里，原先的第一个数据就没有放进去
　   * 最后把取出的第一个数据返回
     * */
    public Object poll() {
        Object o = null;
        if(arrays!=null) {
            o = arrays[0];
            arrays2 = new Object[arrays.length-1];
            for(int i=arrays.length-1;i>0;i--) {
                arrays2[i-1]=arrays[i];
            }
            arrays = null;
            
        }else if(arrays2!=null) {
            o = arrays2[0];
            arrays = new Object[arrays2.length-1];
            for(int i=arrays2.length-1;i>0;i--) {
                arrays[i-1]=arrays2[i];
            }
            arrays2 = null;
        }
        return o;
    }

}

3.栈的实现

package com.sxt.test.java;

public class Stack extends Array{
    
    /**
     * 压栈
     * */
    public void push(Object o) {
        super.add(o);
    }
    
    /**
     * 出栈
     * 取数组的最后一个数据返回
     * 然后新建一个比原来长度-1的数组，从前往后把数据放入新数组，最后一个数据就没有放入
     *
     * 最后把取出的最后一个数据返回
     * */
    public Object pop() {
        Object o = null;
        if(arrays!=null) {
            o = arrays[arrays.length-1];
            arrays2 = new Object[arrays.length-1];
            for(int i=0; i<arrays.length-1; i++) {
                arrays2[i] = arrays[i];
            }
            arrays = null;
            
        }else if(arrays2!=null) {
            o = arrays2[arrays2.length-1];
            arrays = new Object[arrays2.length-1];
            for(int i=0; i<arrays2.length-1; i++) {
                arrays[i] = arrays2[i];
            }
            arrays2 = null;
        }
        return o;
    }
}

4.测试类

/**
         * 动态数组 Array测试
         * */        
        Array a = new Array();
        a.add("a");
        a.add("b");
        a.add("c");
        a.add("d");
        
        System.out.println(a.length());
        for(int i=0;i<a.length();i++) {
            System.out.println(a.get(i));
        }
        System.out.println("------------");
        
        /**
         * Queue测试
         *     */        
        Queue queue= new Queue() ;
        queue.add("a");
        queue.add("b");
        queue.add("c");
        queue.add("d");
        queue.add("e");
        queue.add("f");
        
        System.out.println(queue.length());
        while(queue.length()>0) {
            System.out.println(queue.poll());
        }
        System.out.println("----------");
        
        
        /**
         * 栈测试
         * */
        Stack stack = new Stack();
        stack.push("a");
        stack.push("b");
        stack.push("c");
        stack.push("d");
        stack.push("e");
        stack.push("f");
        System.out.println(stack.length());
        while(stack.length()>0) {
            System.out.println(stack.pop());
        }