[数据结构与算法]数据结构 (四) ---[链表 ](2) [使用链表实现栈 以及 队列 (Java代码实现)]

使用链表实现栈

需要用到创建的栈基本操作实现接口:MyStack

需要用到之前创建的单链表 ==> : MyLink
作为存储容器;

创建MyLinkedStack类实现MyStack接口

/**
 * 使用链表实现栈;
 */
public class MyLinkedStack<T> implements MyStack<T> {
    //使用链表作为底层数据存储;
    private MyLink<T> data;
    //构造方法,初始化栈;
    public MyLinkedStack() {
        data = new MyLink();
    }

    /**
     * 获取栈中的实际元素个数;
     * @return
     */
    @Override
    public int getSize() {
        return data.getSize();
    }

    /**
     * 判断栈是否为空栈;
     */
    @Override
    public boolean isEmpty() {
        return data.isEmpty();
    }

    /**
     * 入栈
     * @param element 需要添加的元素;
     */
    @Override
    public void push(T element) {
        //由链表头部添加结点;
        data.addHead(element);
    }

    /**
     * 出栈
     */
    @Override
    public T pop() {
        //删除链表尾部结点数据;
        return data.removeTail();
    }

    /**
     * 查看栈顶元素;
     */
    @Override
    public T peek() {
        //查看链表尾部结点数据;
        return data.getTail();
    }

    @Override
    public String toString() {
       StringBuilder sbl=new StringBuilder();
       sbl.append("栈顶 <");
        try {
            //循环遍历栈中的元素;注意栈中的元素存在自定义的数组中;
            for (int i = 0; i < this.getSize(); i++) {
                sbl.append(data.get(i));
                //追加分隔符;
                if (i != this.getSize() - 1) {
                    sbl.append(",");
                }
            }
            sbl.append("> 栈顶");
            //调用返回StringBuilder的toString方法;
            return sbl.toString();
            //若为空栈,处理出栈时以及查看栈顶原酸时的参数异常;
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
            return null;
        }
    }
}

使用链表实现队列

需要用到之前创建的队列基本操作实现接口 ==> MyQueue

需要用到上次创建的链表作为底层存储==> MyLink

创建MyLinkedQueue实现接口 MyQueue

/**
 * @create 2021-08-09 
 * 使用链表实现队列;
 * 实现 队列基本操作实现的接口;
 */
public class MyLinkedQueue<E> implements MyQueue<E> {
    //使用链表作为底层数据存储;
    private MyLink<E> data;

    //构造方法;
    public MyLinkedQueue() {
        data = new MyLink<>();
    }

    /**
     * 获取队列元素个数;
     */
    @Override
    public int getSize() {
        return data.getSize();
    }

    /**
     * 判断队列是否为空;
     */
    @Override
    public boolean isEmpty() {
        return data.isEmpty();
    }

    /**
     * 入队方法;
     * @param element 需要添加的元素;
     */
    @Override
    public void enqueue(E element) {
        //从链表尾部添加元素;
        data.addTail(element);
    }

    /**
     * 出队方法;
     */
    @Override
    public E dequeue() {
        //从链表头部删除元素;
        return data.removeHead();
    }

    /**
     * 获取队首元素;
     */
    @Override
    public E getFront() {
        //获取的是链表头结点;
        return data.getHead();
    }
}

分别比较数组实现队列 与 链表实现队列的运行效率

数组实现队列==> MyQueueImpl

出队操作运行效率;

/**
 * @create 2021-08-09 
 * 测试比较数组实现队列 与 链表实现队列的 运行效率;
 */
public class TestTimeForQueue {
    public static void main(String[] args) {
        //定义执行次数;
        int count=10000;

        //使用数组实现的队列;设置初始容量为100;
        MyQueue<Integer> ArrayQueue= new MyQueueImpl(100) ;
        //调用计算时间方法;
        TestTimeForQueue.testTime(ArrayQueue,count);

        //使用链表实现的队列;
        MyQueue<Integer> LinkQueue=new MyLinkedQueue<>();
        //调用计算时间方法;
        TestTimeForQueue.testTime(LinkQueue,count);
    }
    /**
     * 计算运行效率的方法;
     * @param myQueue 队列
     * @param count 执行次数;
     */
    public static void testTime(MyQueue myQueue,int count){
        //开始时间;
        long start=System.nanoTime();
        //执行入队操作;
        for (int i = 0; i < count; i++) {
            myQueue.enqueue(i+10);
        }
        //结束时间;
        long end=System.nanoTime();
        System.out.println("时间==>"+(end-start)/1000000000.0);
    }
}

测试结果:

时间==>0.0012415
时间==>0.1221521

数组实现队列 比 链表实现队列的入队快;

由于在创建数组实现队列的类时,调用了数组尾部添加元素的方法;
在数组尾部添加元素 O(1);在向尾部添加元素时,其他位置的元素不移动

而这个链表实现队列时调用链表尾部添加元素的方法;时间复杂度为O(n)