数据结构怎么玩目录(一)--栈

栈是基本而简单的数据结构之一.所谓基本,是数据结构中有着众多在此基础上搭建起来的结构;所谓简单,是栈只有一个入口,而且实现起来也非常的简单.

栈有一个特性,是"后进先出",这是规定好的,有这种特性的数据结构叫做栈.日常中的例子也很多,比如弹夹,第一个压入弹夹的子弹是最后一个弹出来的.即栈就一个入口.

下面是我写的一个栈的结构,包括了简单的压入栈操作,弹出栈操作等等.

package com.bao.structure.stack;


/**
 * 使用数组实现栈.
 * 
 * @title ArrayStack.java
 * @package com.bao.structure.stack.impl
 * @author Eason
 * @version v1.0, 2013-6-18
 * @param <E>
 * @see com.bao.structure.stack.ArrayStackX
 */
@Deprecated
public class ArrayStack<E> implements Stack<E> {

    private E[] items;
    private int capacity;
    private int top;
    private static final int DEFAULT_CAPACITY = 10;

    public ArrayStack() {
        this(DEFAULT_CAPACITY);
    }

    @SuppressWarnings("unchecked")
    public ArrayStack(int capacity) {
        items = (E[]) new Object[capacity];
        this.capacity = capacity;
        top = -1;
    }

    /**
     * Make the stack logically empty.<br />
     * 清空数组数据.
     */
    public void clear() {
        for (int i = 0; i < capacity; i++) {
            items[i] = null;
        }
        //capacity = 0;
        top = -1;
    }

    /**
     * Test if the stack is logically empty.
     * 
     * @return true if empty, false otherwise.
     */
    public boolean empty() {
        return top == -1;
    }

    /**
     * Get the most recently inserted item in the stack.<br />
     * throw ArrayIndexOutOfBoundsException if the stack is empty.
     * 
     * @return E the most recently inserted element.
     */
    public E peek() {
        if (empty()) {
            throw new ArrayIndexOutOfBoundsException("Stack underflow.");
        }

        return items[top];
    }

    /**
     * remove the most recently inserted element from the stack. <br />
     * throw ArrayIndexOutOfBoundsException if the stack is empty.
     * 
     * @return E the most recently inserted element.
     */
    public E pop() {
        if (empty()) {
            throw new ArrayIndexOutOfBoundsException("Stack underflow.");
        }

        return items[top--];
    }

    /**
     * Insert a new element into the stack.
     */
    public void push(E e) {
        if (top + 1 == capacity) {
            extendArray();
        }
        items[++top] = e;
    }

    /**
     * Internal method to extend the array.<br />
     * 扩展数组.扩大一倍多一,为房子容量为0的情况.
     */
    @SuppressWarnings("unchecked")
    private void extendArray() {
        E[] newDoubleArray = (E[]) new Object[capacity * 2 + 1];
        for (int i = 0; i < capacity; i++) {
            newDoubleArray[i] = items[i];
        }
        items = newDoubleArray;
        capacity = items.length;
    }

    public String toString() {
        StringBuffer result = new StringBuffer("[");

        for (int i = top; i > -1; i--) {
            result.append(items[i]).append(" ");
        }
        result.append("]");
        return result.toString();
    }

}

在这个结构中,我使用数组实现的栈结构,同时定义数组的长度.不过当数组长度不足时,需要注意此时应该讲长度也修改,故我修改了这种方式,即下面一个升级版.

package com.bao.structure.stack;


/**
 * 使用数组实现栈.升级版<br />
 * 删除数组长度的变量,防止在进行操作时没用同时修改而出错.
 * 
 * @title ArrayStack.java
 * @package com.bao.structure.stack.impl
 * @author Eason
 * @version v1.0, 2013-6-18
 * @param <E>
 * @see com.bao.structure.stack.ArrayStack
 */
public class ArrayStackX<E> implements Stack<E> {

    private E[] items;
    private int top;
    private static final int DEFAULT_CAPACITY = 10;

    public ArrayStackX() {
        this(DEFAULT_CAPACITY);
    }

    @SuppressWarnings("unchecked")
    public ArrayStackX(int capacity) {
        items = (E[]) new Object[capacity];
        top = -1;
    }

    /**
     * Make the stack logically empty.<br />
     * 清空数组数据.
     */
    public void clear() {
        for (int i = 0; i < items.length; i++) {
            items[i] = null;
        }
        //items = (E[]) new Object[0];
        top = -1;
    }

    /**
     * Test if the stack is logically empty.
     * 
     * @return true if empty, false otherwise.
     */
    public boolean empty() {
        return top == -1;
    }

    /**
     * Get the most recently inserted item in the stack.<br />
     * throw ArrayIndexOutOfBoundsException if the stack is empty.
     * 
     * @return E the most recently inserted element.
     */
    public E peek() {
        if (empty()) {
            throw new ArrayIndexOutOfBoundsException("Stack underflow.");
        }

        return items[top];
    }

    /**
     * remove the most recently inserted element from the stack. <br />
     * throw ArrayIndexOutOfBoundsException if the stack is empty.
     * 
     * @return E the most recently inserted element.
     */
    public E pop() {
        if (empty()) {
            throw new ArrayIndexOutOfBoundsException("Stack underflow.");
        }

        return items[top--];
    }

    /**
     * Insert a new element into the stack.
     */
    public void push(E e) {
        if (top + 1 == items.length) {
            extendArray();
        }
        items[++top] = e;
    }

    /**
     * Internal method to extend the array.<br />
     * 扩展数组.扩大一倍多一,为房子容量为0的情况.
     */
    private void extendArray() {
        @SuppressWarnings("unchecked")
        E[] newDoubleArray = (E[]) new Object[items.length * 2 + 1];
        for (int i = 0; i < items.length; i++) {
            newDoubleArray[i] = items[i];
        }
        items = newDoubleArray;
    }

    public String toString() {
        StringBuffer result = new StringBuffer("[");

        for (int i = top; i > -1; i--) {
            result.append(items[i]).append(" ");
        }

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

}

如果有new hand,可以自己看一下,不要被这么多代码吓着,其实还是蛮简单的.

栈也有很多应用.比如单词逆序,即将一个单词以从右向左的顺序显示.在此我也写出来,不过大家可以想想,然后再看,非常简单的.

package intelligence.stack;

import com.bao.structure.stack.ArrayStackX;
import com.bao.structure.stack.Stack;

/**
 * 单词逆序.
 *
 * @title:         WordReverse.java
 * @package:     intelligence.stack
 * @author:        Eason
 * @date:        2013-6-18
 * @version:    v1.0
 */
public class WordReverse {

    public static String reverse(String arg) {

        String result = "";

        if (arg == null) {
            throw new NullPointerException("arg is null.");
        }

        Stack<Character> stack = new ArrayStackX<Character>();

        for (int i = 0; i < arg.length(); i++) {
            stack.push(arg.charAt(i));
        }

        while (!stack.empty()) {
            Character ch = stack.pop();
            result = result + ch;
        }

        return result;
    }

    public static void main(String[] args) {

        String reverseWord = WordReverse.reverse("goodgoodgoodgoodgoodgoodgoodgoodgoodgood");
        System.out.println(reverseWord);

    }

}

好了,今天的栈就到这里,如果有些写的不正确的,请各位高手指正,毕竟小弟才疏学浅.谢谢