自定义栈和队列

一、栈

首先来使用简单的方式LinkedList来定义

import java.util.LinkedList;

/**
 * Created by lili on 15/11/14.
 */
public class MyStack {
    private LinkedList linkedList;

    public MyStack() {
        linkedList = new LinkedList();
    }

    public void push(Object o) {
        linkedList.addFirst(o);
    }

    public Object pop() {
        //删除并返回
        return linkedList.removeFirst();
    }

    public boolean isEmpty() {
        return linkedList.isEmpty();
    }
}

再使用数组的方式来定义，这个包括了容量的扩充

（1）首先定义一个接口

public interface IStack<T> {  
    //元素出栈，并返回出栈元素  
    public T pop();  
      
    //元素入栈  
    public void push(T element);  
      
    //获取栈顶元素  
    public T peek();  
      
    //判断栈是否为空  
    public boolean isEmpty();  
      
    public void clear();  
}  

（2）再来实现该接口

public class ArrayStack<T> implements IStack<T> {  
    private final int DEFAULT_SIZE = 3;  
    private int size = 0;  
    private int capacity = 0;  
      
    //top指向下一个能够添加元素的位置  
    private int top = 0;  
    private Object[] array;  
      
    public ArrayStack(){  
        this.capacity = this.DEFAULT_SIZE;  
        this.array = new Object[this.capacity];  
        this.size = 0;  
    }  
      
    public ArrayStack(int capacity){  
        this.capacity = capacity;  
        this.array = new Object[this.capacity];  
        this.size = 0;  
    }  
      
    @Override  
    public boolean isEmpty() {  
        // TODO Auto-generated method stub  
        return size == 0;  
    }  
  
    @Override  
    public T peek() {  
        // TODO Auto-generated method stub  
        return (T)this.array[this.top-1];  
    }  
  
    @Override  
    public T pop() {  
        // TODO Auto-generated method stub  
        T element = (T)this.array[top - 1];  
        this.array[top-1] = null;  
        this.size--;  
        return element;  
    }  
  
    @Override  
    public void push(T element) {  
        // TODO Auto-generated method stub  
        if(this.size < this.capacity){  
            this.array[top] = element;  
            this.top++;  
            this.size ++;  
        }else{  
//          System.out.println("out of array");  
            enlarge();  
            push(element);  
        }  
    }  
      
    public void enlarge(){  
        this.capacity = this.capacity + this.DEFAULT_SIZE;  
        Object[] newArray = new Object[this.capacity];  
        System.arraycopy(array, 0, newArray, 0, array.length);  
        Arrays.fill(array, null);  
        this.array = newArray;  
    }  
      
    public int size(){  
        return this.size;  
    }  
  
    @Override  
    public void clear() {  
        // TODO Auto-generated method stub  
        Arrays.fill(array, null);  
        this.top = 0;  
        this.size = 0;  
        this.capacity = this.DEFAULT_SIZE;  
        this.array = new Object[this.capacity];  
    }  
}  

二、队列

（1）可以使用两个栈的方式来实现队列，如下使用的是LinkedList的方式

public class MyQueue
{
  private LinkedList list = new LinkedList();
  public void clear()//销毁队列
  {
      list.clear();
  }
  public boolean QueueEmpty()//判断队列是否为空
  {
      return list.isEmpty();
  }
  public void enQueue(Object o)//进队
  {
      list.addLast(o);
  }
  public Object deQueue()//出队
  {
      if(!list.isEmpty())
      {
          return list.removeFirst();
      }
      return "队列为空";
  }
  public int QueueLength()//获取队列长度
  {
      return list.size();
  }
  public Object QueuePeek()//查看队首元素
  {
      return list.getFirst();
  }

（2）使用数组的方式来定义队列

public class Queue<E> {  
    private int front;  
    private int rear;  
    private int count;  
    private int queueSize;  
    private E[] object;  
    public Queue() {  
        this(10);  
    }  
    public Queue(int queueSize) {  
        this.queueSize = queueSize;  
        this.object = (E[]) new Object[queueSize];  
        this.front = 0;  
        this.rear = 0;  
        this.count = 0;  
    }  
    public boolean isEmpty() {  
        return count == 0;  
    }  
    public boolean isFull() {  
        return count == queueSize;  
    }  
    public void push(E o) {  
        if (this.isFull()) {  
            throw new RuntimeException("队列是满的");  
        }  
        count++;  
        object[rear] = o;  
        rear = (rear + 1) % queueSize;  
    }  
    public E pop() {  
        E result;  
        if (this.isEmpty()) {  
            throw new RuntimeException("队列是空的");  
        }  
        result = this.object[front];  
        count--;  
        front = (front + 1) % queueSize;  
        return result;  
    }  
    public E peek() {  
        if (this.isEmpty()) {  
            throw new RuntimeException("队列是空的");  
        }  
        return this.object[front];  
    }  
    public int getCount() {  
        return count;  
    }  
    public int getQueueSize() {  
        return queueSize;  
    }  
    public int getFront() {  
        return front;  
    }  
    public int getRear() {  
        return rear;  
    }  
    public E[] getObject() {  
        return object;  
    }  
}