java基础---基于数组实现栈

本文是基于数组为底层来实现堆栈，包括堆栈的进栈、出栈、堆栈是否为空、获取栈顶元素

• 数组的基本实现如下：

public class DynamicArray<E> {
		private E[] data;
		private int size;
		//有参构造函数，根据传入参数构造数组的容量
		public ArrayDynamic(int cap){
			this.data = (E[]) new Object[cap];
			this.size = 0;
		}
		//无参构造函数,默认数组的容量为10
		public DynamicArray(){
			this(10);
		}
		//获取数组的容量
		public int getCapacity(){
			return this.data.length;
		}
		//获取数组中元素的个数
		public int getSize(){
			return this.size;
		}
		//判断数组是否为空
		public boolean isEmpty(){
			return this.size==0;
		}
		/**
		 * 往数组中添加元素
		 * @param index:索引
		 * @param e:添加的元素
		 */
		public void add(int index, E e){
			if(index <0 || index >this.size){
				throw new IllegalArgumentException("添加失败，插入的索引出错！");
			}
			//扩容
			if(this.size == this.data.length){
				this.resize(this.getCapacity()*1.5);
			}
		
			for(int i = this.size; i > index; i--){
				data[i] = data[i-1];
			}
			this.data[index]=e;
			this.size++;
		}
		//往数组首位置添加元素
		public void addFirst(E e){
			this.add(0, e);
		}
		//在所有数组元素后添加元素
		public void addLast(E e){
			this.add(this.size, e);
		}
		//获取index位置的元素
		public E getElement(int index){
			if(index < 0 || index >=this.size){
				throw new IllegalArgumentException("getElement-->index出错！");
			}
			return this.data[index];
		}
		//修改index位置的元素
		public void setElement(int index, E e){
			if(index < 0 || index >=this.size){
				throw new IllegalArgumentException("setElement-->index出错！");
			}
			this.data[index]=e;
		}
		//查找元素e是否在数组中，返回索引
		public int find(E e){
			for(int i =0 ; i< this.size; i++){
				if(this.data[i] == e)return i;
			}
			return -1;
		}
		//查看数组是否包含该元素
		public boolean contains(E e){
			return this.find(e) != -1;
		}
		//删除index元素，并返回删除元素
		public E remove(int index){
			if(index <0 || index >=this.size){
				throw new IllegalArgumentException("删除失败-->index出错");
			}
			E res = this.data[index];
			for(int i = index; i<this.size-1; i++){
				this.data[i]=this.data[i+1];
			}
			this.size--;
			this.data[size]=null;
			if(this.size <= this.data.length/2)this.resize(this.data.length/2);
			return res;
		}
		//删除数组第一个元素
		public E removeFirst(){
			return this.remove(0);
		}
		//删除数组最后一个元素
		public E removeLast(){
			return this.remove(this.size-1);
		}
		// 将数组空间的容量变成newCap大小
		private void resize(int newCap){
			E[] newData = (E[])new Object[newCap];
			for(int i = 0 ; i < size ; i ++)
		        newData[i] = this.data[i];
		    this.data = newData;
		}

		@Override
		public String toString() {
			StringBuffer sb = new StringBuffer();
			sb.append(String.format("Array: size = %d , cap = %d\n", size, data.length));
			sb.append('[');
		    for(int i = 0 ; i < this.size ; i ++){
		        sb.append(this.data[i]);
		        if(i != this.size - 1)
		            sb.append(", ");
		    }
		    sb.append(']');
		    return sb.toString();
        }	
}

• 栈是一种后进先出的数据结构，限定只能在一端（栈顶）进行数据的插入和删除

• 栈的定义接口

  public interface Stack<E> {
  	//获取栈中的元素个数
  	int getSize();
  	//判断栈是否为空
  	boolean isEmpty();
  	//入栈
  	void push(E e);
  	//出栈并返回栈顶元素
  	E pop();
  	//栈顶指针的指向元素
  	E peek();
  }
  

  • 实现接口

    import Array.DynamicArray;
    
    public class ArrayStack<E> implements Stack<E> {
    	private ArrayDynamic<E> array;
    	//根据有参构造方法，建立堆栈的空间大小
        public ArrayStack(int cap){
            array = new ArrayDynamic<E>(cap);
        }
        //无参构造方法，默认堆栈的空间大小为10
        public ArrayStack(){
            array = new DynamicArray<E>();
        }
    	@Override
    	public int getSize() {
    		return this.array.getSize();
    	}
    
    	@Override
    	public boolean isEmpty() {
    		return this.array.isEmpty();
    	}
    	
    	@Override
    	public void push(E e) {
    		this.array.addLast(e);
    	}
    
    	@Override
    	public E pop() {
    		return this.array.removeLast();
    	}
    
    	@Override
    	public E peek() {
    		return this.array.getElement(this.getSize()-1);
    	}
    }
    

    • 复写toString方法和测试

      	@Override
          public String toString(){
              StringBuffer sb = new StringBuffer();
              sb.append("Stack: [");
              for(int i = 0 ; i < this.array.getSize() ; i ++){
                  sb.append(this.array.getElement(i));
                  if(i != this.array.getSize() - 1)
                      sb.append(", ");
              }
              sb.append("] top");
              return sb.toString();
          }
      	public static void main(String[] args) {
      
              ArrayStack<Integer> stack = new ArrayStack<>();
              //进栈
              for(int i = 0 ; i < 10 ; i ++){
                  stack.push(i);
                  System.out.println(stack);
              }
              //出栈
              stack.pop();
              System.out.println(stack);
              System.out.println("栈顶元素："+stack.peek());
              stack.pop();
              System.out.println(stack);
              System.out.println("栈顶元素："+stack.peek());
              stack.pop();
              System.out.println(stack);
              System.out.println("栈顶元素："+stack.peek());
          }
      

      • 完整代码

        import Array.DynamicArray;
        public class ArrayStack<E> implements Stack<E> {
        	private ArrayDynamic<E> array;
        	//根据有参构造方法，建立堆栈的空间大小
            public ArrayStack(int cap){
                array = new DynamicArray<E>(cap);
            }
            //无参构造方法，默认堆栈的空间大小为10
            public ArrayStack(){
                array = new DynamicArray<E>();
            }
        	@Override
        	public int getSize() {
        		return this.array.getSize();
        	}
        
        	@Override
        	public boolean isEmpty() {
        		return this.array.isEmpty();
        	}
        	
        	@Override
        	public void push(E e) {
        		this.array.addLast(e);
        	}
        
        	@Override
        	public E pop() {
        		return this.array.removeLast();
        	}
        
        	@Override
        	public E peek() {
        		return this.array.getElement(this.getSize()-1);
        	}
        	@Override
            public String toString(){
                StringBuffer sb = new StringBuffer();
                sb.append("Stack: [");
                for(int i = 0 ; i < this.array.getSize() ; i ++){
                    sb.append(this.array.getElement(i));
                    if(i != this.array.getSize() - 1)
                        sb.append(", ");
                }
                sb.append("] top");
                return sb.toString();
            }
        	public static void main(String[] args) {
        
                ArrayStack<Integer> stack = new ArrayStack<>();
                //进栈
                for(int i = 0 ; i < 10 ; i ++){
                    stack.push(i);
                    System.out.println(stack);
                }
                //出栈
                stack.pop();
                System.out.println(stack);
                System.out.println("栈顶元素："+stack.peek());
                stack.pop();
                System.out.println(stack);
                System.out.println("栈顶元素："+stack.peek());
                stack.pop();
                System.out.println(stack);
                System.out.println("栈顶元素："+stack.peek());
            }
        }