数据结构之栈和队列

数据结构之栈和队列

栈

栈也是一种线性数据结构,在栈中只能从栈顶添加元素和栈顶取出元素(后进先出)

栈的具体操作

接口 Stack

T pop() 出栈操作

T push(T ele) 入栈操作

int getSize() 获取元素个数

boolean isEmpty() 判断栈是否为空

T peek() 查看栈顶元素

底层操作为上次写的数组结构

package com.lsy.lesson;

/**
 * 栈的基本操作
 * @param <T>
 */
public interface Stack<T> {
     int getSize();//获取栈的元素个数

     boolean isEmpty();//判断栈是否为空

     void push(T ele);//栈顶入栈

     T pop();//出栈

     T peek();//查看栈顶元素
}

package com.lsy.lesson;

public class MyStack<T> implements Stack<T> {
    private Myarrays<T> data;//数据容器
    private int size;//栈中元素个数
    /*
    栈的初始化
     */
    public MyStack(){
        data = new Myarrays<>();
        size = 0;
    }
    @Override
    public int getSize() {
        return size;
    }
    @Override
    public boolean isEmpty() {
        return size==0;
    }
    @Override
    public void push(T ele) {
        try {
            data.addTail(ele);
            size++;
        }catch(IllegalAccessException e){
            e.printStackTrace();
        }
    }
    @Override
    public T pop() {
        T result=null;
        try {
            result = data.removeEle(size - 1);
            size--;
        }catch (IllegalAccessException e){
            e.printStackTrace();
        }
        return result;
    }

    @Override
    public T peek() {
        T result = null;
        try {
            result =  data.getTail();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return result;
    }
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append("栈中有"+size+"个元素----->");
        sb.append("栈底"+"[");
        try {
            for (int i = 0; i < size; i++) {

                sb.append(data.getEleByindex(i));
                if (i != size - 1) {
                    sb.append(",");
                }
            }
            sb.append("]"+"栈顶");
        }catch (IllegalAccessException e) {
                e.printStackTrace();
                return null;
            }

        return sb.toString();
    }
}

时间复杂度分析

出栈操作 O(1)

入栈操作 O(1)

查看栈顶元素 O(1)

队列

在对队列进行操作时,从队首进行出队操作.队尾进行入队操作(先进先出)

队列的具体操作

接口 Queue

void enQueue(T ele) 入队操作

T deQueue() 出队操作

T getFront() 获取队首元素

int getSize() 获取元素个数

boolean isEmpty() 判断是否为空

package com.lsy.lesson;

public interface Queue<T> {
    int getSize();
    boolean isEmpty();
    void enQueue(T ele);//入队
    T deQueue();//出队
    T getFront();//查看对首元素

}

package com.lsy.lesson;

public class MyQueue<T> implements Queue<T> {
    //创建容器
    private Myarrays<T> data;
    private int size;

    public MyQueue() {
        data = new Myarrays<>();
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public void enQueue(T ele) {
        try {
            data.addTail(ele);
            size++;
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    @Override
    public T deQueue() {
        T result = null;
        try {
            result = data.removeEle(0);
            size--;
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return result;
    }

    @Override
    public T getFront() {
        T result = null;
        try {
            result = data.getHead();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return result;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("队列元素有" + size + "个---->");
        sb.append("对首[");
        try {
            for (int i = 0; i < size; i++) {

                sb.append(data.getEleByindex(i));
                if (i != size - 1) {
                    sb.append(",");
                }
            }
            sb.append("]队尾");
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return (sb.toString());
    }
}

时间复杂度分析

出对操作 O(1)

入对操作 O(n)

查看栈顶元素 O(1)