java之实现 线性表、栈和队列

    线性表是存储顺序牌类的数据时最常用的数据结构。

    实现线性表有两种方式。第一种是使用数组存储线性表的元素。数组是动态创建的。超过数组的容量时，创建一个

新的更大的数组，并且将当前数组中的元素复制到新建的数组中。另一种方法是用链表结构实现。链表由节点组成，每

个结点都是动态生成的，用来存储一个元素。所有的结点连接成一个线性表。

    对于线性表的主要操作有：

    1、提取线性表的元素

    2、在线性表中插入一个新元素

    3、从线性表中删除一个元素

    4、获取线性表中元素的个数

    5、查找线性表中是否包含某个元素

    6、判断线性表是否为空

下面这个接口类定义了常用的操作。

package list_test;public interface MyList {public void add(Object o);public void add(int index, Object o);public void clear();public boolean contains(Object o);public Object get(int index);public int indexOf(Object o);public boolean isEmpty();public int lastIndexOf(Object o);public boolean remove(Object o);public Object remove(int index);public Object set(int index, Object o);public int size();}

然后用MyAbstractList实现其中一部分方法：

package list_test;public abstract class MyAbstractList implements MyList {protected int size = 0;protected MyAbstractList() {}protected MyAbstractList(Object[] objects) {for (int i = 0; i < objects.length; i++) {this.add(objects[i]);}}public void add(Object o) {add(size, o);}public boolean isEmpty() {return size == 0;}public int size() {return size;}public boolean remove(Object o) {if (indexOf(o) >= 0) {remove(indexOf(o));return true;} else {return false;}}}

接下来用数组实现线性表。数组的类型是Object[]类型，所以，数组中每个元素实际元素存储的是对象的引用。

package list_test;/** * @author  */public class MyArrayList extends MyAbstractList {public static final int INITIAL_CAPACITY = 16;private Object[] data = new Object[INITIAL_CAPACITY];public MyArrayList() {}public MyArrayList(Object[] objects) {data = objects;size = objects.length;}@Overridepublic void add(int index, Object o) {ensureCapacity();for (int i = size - 1; i >= index; i--) {data[i + 1] = data[i];}data[index] = 0;size++;}private void ensureCapacity() {if (size >= data.length) {Object[] newData = new Object[data.length * 2];System.arraycopy(data, 0, newData, 0, data.length);data = newData;}}@Overridepublic void clear() {// TODO Auto-generated method stubdata = new Object[INITIAL_CAPACITY];}@Overridepublic boolean contains(Object o) {// TODO Auto-generated method stubfor (int i = 0; i < size; i++) {if (o.equals(data[i])) {return true;}}return false;}@Overridepublic Object get(int index) {// TODO Auto-generated method stubreturn data[index];}@Overridepublic int indexOf(Object o) {// TODO Auto-generated method stubfor (int i = 0; i < data.length; i++) {if (o.equals(data[i])) {return i;}}return -1;}@Overridepublic int lastIndexOf(Object o) {// TODO Auto-generated method stubfor (int i = size - 1; i >= 0; i--) {if (o.equals(data[i])) {return i;}}return -1;}@Overridepublic Object remove(int index) {// TODO Auto-generated method stubObject o = data[index];for (int i = index; i < size - 1; i++) {data[i] = data[i + 1];}size--;return o;}@Overridepublic Object set(int index, Object o) {// TODO Auto-generated method stubObject oldObject = data[index];data[index] = o;return oldObject;}public String toString(){StringBuffer result = new StringBuffer("[");for (int i = 0; i < size; i++) {result.append(data[i]);if (i < size -1) {result.append(", ");}}return result.toString() + "]";}}

   栈可以看作是一种特殊的线性表，访问、插入和删除它的元素只能在栈的一端来进行。

   队列表示一个排队等待的线性表。它的元素只能从队尾插入，从队首访问和删除。

    由于栈只允许在栈顶进行插入和删除操作。所以用数组线性表来实现栈比用链表来实现效率高。由于删除是在线

性表的开头进行，所以，用链表来实现队列比用数组线性表效率高。

下面是用包装方式实现的栈类和队列类。

package queue_and_stack;import list_test.MyLinkedList;//栈public class MyStack {private MyLinkedList list = new MyLinkedList();public void push(Object o) {list.addLast(o);}public Object pop() {return list.removeLast();}public int getSize() {return list.size();}public String toString() {return "Stack: " + list.toString();}}

package queue_and_stack;import list_test.MyLinkedList;//队列public class MyQueue {private MyLinkedList list = new MyLinkedList();public void enqueue(Object o) {list.addLast(o);}public Object dequeue() {return list.removeFirst();}public int getSize() {return list.size();}public String toString() {return "Queue: " + list.toString();}}

下面是一个测试类。

package queue_and_stack;public class TestStackQueue {public static void main(String[] args) {//// test stackMyStack stack = new MyStack();stack.push("a");System.out.println("(1)" + stack);stack.push("b");System.out.println("(2)" + stack);stack.push("c");stack.push("d");System.out.println("(3)" + stack);System.out.println("(4)" + stack.pop());System.out.println("(5)" + stack.pop());System.out.println("(6)" + stack);//// test queueMyQueue queue = new MyQueue();queue.enqueue("1");System.out.println("(1) " + queue);queue.enqueue("2");System.out.println("(2) " + queue);queue.enqueue("3");queue.enqueue("4");System.out.println("(3) " + queue);System.out.println("(4) " + queue.dequeue());System.out.println("(5) " + queue.dequeue());System.out.println("(6) " + queue);}}

对于一个栈来说，push(o)方法是将一个元素添加到栈顶，pop()方法是将栈顶的元素删除并返回此元素。

对于一个队列来书，enqueue(o)方法是将一个元素添加到队尾，dequeue()方法是将队列头的元素删除。