数据结构 玩转数据结构 4-6 使用链表实现栈

0　　　　课程地址

https://coding.imooc.com/lesson/207.html#mid=13449

 

1　　　　重点关注

1.1　　　　使用链表实现栈代码解析

见3.1

 

1.2　　　　数组实现栈 和 链表实现栈的性能对比 性能解析

• 结论：

超过100w,数量越大，数组实现栈的性能越好

如3.2，使用数组实现栈性能更好。

 

• 原因：

虽然二者都是O(1)级别的复杂度，

但是，链表实现的栈每次push都要new一个节点，这也导致了随着数量级的提升，性能差异越来越明显。　　　

数组扩容虽然也浪费时间，但是前期扩容较多，每次扩容都是扩容两倍，后续扩容时间明显减少，所以用数组实现栈更加适合

 

2　　　　课程内容

3　　　　Coding

3.1　　　　使用链表实现栈代码解析

• 主类：

package com.company;

public class LinkedListStack<E> implements Stack<E> {

    private LinkedList<E> linkedList;


    public LinkedListStack(){
        linkedList = new LinkedList<>();
    }

    @Override
    public void push(E e) {
        linkedList.addFirst(e);
    }

    @Override
    public E pop() {
        return linkedList.removFirst();
    }

    @Override
    public E peek() {
        return linkedList.findByFirst();
    }

    @Override
    public boolean isEmpty() {
        return linkedList.isEmpty();
    }

    @Override
    public int getSize() {
        return linkedList.getSize();
    }

    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer("LinkedListStack:pop ");
        sb.append(linkedList);
        return sb.toString();
    }
}

 

 

• 测试类：

public static void main(String[] args) {

        LinkedListStack<Integer> linkedListStack = new LinkedListStack<>();
        for(int i = 0;i < 5;i++){
            linkedListStack.push(i);
            System.out.println(linkedListStack);
        }

        linkedListStack.pop();
        System.out.println(linkedListStack);

        System.out.println(linkedListStack.peek());

        System.out.println(linkedListStack.getSize());

        System.out.println(linkedListStack.isEmpty());

    }

 

 

• 测试结果：

LinkedListStack:pop 0->Null
LinkedListStack:pop 1->0->Null
LinkedListStack:pop 2->1->0->Null
LinkedListStack:pop 3->2->1->0->Null
LinkedListStack:pop 4->3->2->1->0->Null
LinkedListStack:pop 3->2->1->0->Null
3
4
false

Process finished with exit code 0

 

3.2　　　　数组实现栈 和 链表实现栈的性能对比 代码实现

• 测试类：

/**
     * 主测试方法，测试循环队列和数组队列性能
     * @author weidoudou
     * @date 2022/10/27 7:24
     * @param stack 请添加参数描述
     * @param  count 请添加参数描述
     * @return long
     **/
    public static double testStack(Stack<Integer> stack, int count){
        long startTime = System.nanoTime();

        //入队
        for(int i = 0;i<count;i++){
            stack.push(i);
        }

        //出队
        for(int i = 0;i<count;i++){
            stack.pop();
        }


        long endTime = System.nanoTime();
        double resultTime = (endTime-startTime)/1000000000.0;
        return resultTime;
    }


    public static void main(String[] args) {

        int count = 1000000;
        //数组实现的栈
        Stack<Integer> arrayStack = new StackFirst<>();
        //链表实现的栈
        Stack<Integer> linkedStack = new LinkedListStack<>();

        double time1 = testStack(arrayStack,count);
        System.out.println("arrayStack time1==="+time1);
        double time2 = testStack(linkedStack,count);
        System.out.println("linkedStack time2==="+time2);

    }

 

• 测试结果：

arrayStack time1===0.0325398
linkedStack time2===0.204648

Process finished with exit code 0