数据结构-栈与队列

　　栈：

　　通俗理解：对于一个数组的插入和删除来讲，栈就像是一个盒子一样，所插入进来的数据都是先进后出，删除的数据都是后进先出；

　　画图理解：这样子画应该很好理解了吧，所有的数据都像是盒子的形式一样存贮和释放；

　　

　　直接上代码：

　　创建一个栈；

package inn;
/**
 * 栈
 * @author caizhou
 *
 */

public class myStack {
    
    private long[] arr;
    private int top;
    
    public myStack(){
        arr =new long[20];
        top = -1;
    }
    
    public myStack(int maxsize){
        arr = new long[maxsize];
        top = -1;
    }
    
    /**
     * 添加数据；
     * @param value
     */
    public void insert(long value){
        arr[++top] = value;
    }
    
    /**
     * 移除数据。
     */
    public long pop(){
        return arr[top--];
    }
    
    /**
     * 查看数据
     */
    
    public long peek(){
        return arr[top];
    }
    /**
     * 判断是否为空；
     * @return
     */
    public boolean isEmpty(){
        return top==-1;
    }
    /**
     * 判断是否溢出；
     * @return
     */
    public boolean isFull(){
        return top == arr.length -1;
    }
}

　　测试栈：

　　

package inn;

public class testStack {
     public static void main(String[] args) {
        
         myStack my = new myStack(4);
         my.insert(23);
         my.insert(12);
         my.insert(21);
         my.insert(60);
         
         while(!my.isEmpty()){
             System.out.println(my.pop());
         }
    }
}

　　测试结果：

60
21
12
23

　　队列：

　　通俗理解：队列，和栈基本上是完全相反的，对于数组的插入和删除来讲，队列就像是在电影院排队一样，先进先出，后进后出；

　　画图理解：符合先进先出，后进后出的理念；

　　

 　　直接上代码：

　　创建队列；

package inn;
/**
 * 队列
 * @author caizhou
 *
 */
public class myQueue {
        
    private long[] arr;
    /**
     * 总长度，队头，队尾
     */
    private int element;
    private int front;
    private int end;
    
    public myQueue(){
        arr = new long[20];
        element = 0;
        front = 0;
        end = -1;
        
    }
    public myQueue(int maxsize){
        arr = new long[maxsize];
        element = 0;
        front = 0;
        end = -1;
    }
    
    public void insert (int value){
        arr[++end] = value;
        if(end == arr.length-1){
            end = -1;
        }
        element++;
    }
    
    public long delete(){
        long value = arr[front++];
        if(front ==arr.length){
            front =0;
        }
        element--;
        return value;
    }
    
    /**
     * 从队头查看数据；
     * @return
     */
    public long peek(){
        if(front ==arr.length){
            front =0;
        }
        return arr[front];
    }
    
    public Boolean isEmpty(){
        return element ==0;
    }
    public boolean isFull(){
        return element ==arr.length-1;
    }
}

　　测试队列：

　　

package inn;

public class testMyQueue {
        public static void main(String[] args) {
            
            myQueue my = new myQueue(4);
            my.insert(23);
            my.insert(32);
            my.insert(13);
            my.insert(53);
            System.out.println(my.peek());
            while(!my.isEmpty()){
                System.out.print(my.delete() + ",");
            }
            
            my.insert(10);
//            while(!my.isEmpty()){
//                System.out.print(my.delete() + ",");
//            }
            System.out.println(my.peek());
        }
}

　　测试结果：

　　

23
23,32,13,53,10

　　到此，栈和队列就讲完了，希望可以帮大家理解的清楚；