数据结构java（六）受限制的线性表 ①顺序结构实现（顺序栈ArrayStack）

应用

1.创建Stack栈接口

/**
 * 先进后出
 * 栈接口
 * @author Administrator
 */
public interface Stack {
    /**
     * 返回栈的大小
     * @return
     */
    int getSize();

    /**
     * 判断栈是否为空
     * @return
     */
    boolean isEmpty();

    /**
     * 元素e入栈
     * @param e
     */
    void push(Object e);

    /**
     * 栈顶元素出栈
     * @return
     */
    Object pop();

    /**
     * 所有元素出栈
     */
    void popAll();

    /**
     * 取栈顶元素
     * @return
     */
    Object peek();
}

2.顺序栈ArrayStack的实现

/**
 * 数组实现栈
 * @author Administrator
 */
public class ArrayStack implements Stack {
    /**
     * 栈的大小
     */
    private int size;
    /**
     * 底层是一个数组
     */
    private Object[] elementData;


    /**
     * @param initialCapacity 数组初始长度
     */
    public ArrayStack(int initialCapacity){
        //给数组分配指定的空间
        elementData = new Object[initialCapacity];
        //指定顺序表元素个数
//        size = 0; int初始值是0
    }
    /**
     * 返回栈的大小
     *
     * @return
     */
    @Override
    public int getSize() {
        return size;
    }

    /**
     * 判断栈是否为空
     *
     * @return
     */
    @Override
    public boolean isEmpty() {
        return size==0;
    }

    /**
     * 元素e入栈
     *
     * @param e
     */
    @Override
    public void push(Object e) {
        if (size>=elementData.length) {
            throw new MyArrayIndexOutOfBoundsException("栈满");
        }
        elementData[size] = e;
        size++;
    }

    /**
     * 栈顶元素出栈
     *
     * @return
     */
    @Override
    public Object pop() {
        if (size==0){
            throw new MyArrayIndexOutOfBoundsException("空栈");
        }
        Object elementDatum = elementData[size-1];
        elementData[size-1]=null;
        size--;
        return elementDatum;
    }

    /**
     * 所有元素出栈
     */
    @Override
    public void popAll() {
        if (size == 0){
            throw new MyArrayIndexOutOfBoundsException("空栈");
        }
        StringBuilder builder = new StringBuilder("[");
        for (int i = size;i>0;i--){
            if (i!=1){
                builder.append(pop()+",");
            }else {
                builder.append(pop());
            }
        }
        builder.append("]");
        System.out.println(builder);
    }

    /**
     * 取栈顶元素
     *
     * @return
     */
    @Override
    public Object peek() {
        if (size==0){
            throw new MyArrayIndexOutOfBoundsException("空栈");
        }
        return elementData[size-1];
    }

    @Override
    public String toString() {
        if (size == 0){
            return "[]";
        }
        StringBuilder builder = new StringBuilder("[");
        for (int i = 0;i<size;i++){
            if (i!=size-1){
                builder.append(elementData[i]+",");
            }else {
                builder.append(elementData[i]);
            }
        }
        builder.append("]");
        return builder.toString() ;
    }
}

3.测试

/**
 * 测试
 * @author Administrator
 */
public class ArrayStackTest {
    private Stack stack;
    @Before
    public void setUp() throws Exception {
        stack = new ArrayStack(4);
        stack.push(1);
        stack.push(2);
//        stack.push(3);
        System.out.println("操作前："+stack+"大小："+stack.getSize());
    }

    @After
    public void tearDown() throws Exception {
        System.out.println("操作后："+stack+"大小："+stack.getSize());
    }

    @Test
    public void push() {
        stack.push(1);
        stack.push(2);
    }

    @Test
    public void pop() {
        stack.push(3);
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        stack.push(4);
        stack.push(5);
//        stack.push(6);
//        stack.push(7);
        stack.popAll();
    }

    @Test
    public void peek() {
        System.out.println(stack.peek());
    }
    @Test
    public void popAll() {
        stack.popAll();
    }
}

应用：用栈实现十进制转换二进制

public static void main(String[] args) {    
        //给定一个十进制数
        int n =13;
        //把十进制转换为二进制
        int t = n;
        //定义一个空栈
        Deque stack  = new LinkedList();
        do {
            //除以2求余
            int mod = t % 2;
            //输出余数//入栈
            stack.push(mod);
            //除以2得到商//使用商做被除数
            t = t / 2;
        }while (t>0);//当商大于0
        //输出结果
        System.out.print(n+"--------------->");
        while (!stack.isEmpty()){//栈非空
            System.out.print(stack.pop());
}

下一篇：数据结构java（七）受限制的线性表 ②链式结构实现（链栈LinkedStack）