自定义栈和队列

Posted 2022-11-29 劲火星空

一、栈

首先来使用简单的方式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;