用LinkedList模拟一个堆栈或者队列数据结构 总结: LinkedList知识点

/**
用LinkedList模拟一个堆栈或者队列数据结构。
创建一个堆栈和队列数据结构对象，该对象中使用LinkedList来完成的。
知识点总结:
1.LinkedList特点:链表式数据结构. 重复有序,查询速度慢,增删速度快.不同步的.
2.LinkedList除了实现List接口增删改查的功能外,有一些特有的方法,能够实现在List(列表)的开头和结尾
插入,删除,获取等特有功能.这就是为什么LinkedList能够模拟一个堆栈,或者队列,双端队列的数据结构了.
涉及知识点:
1.什么是堆栈?什么是队列呢?
堆栈比喻弹夹,遵循先进后出原则.First In Last Out.FILO.
理解:先进入的元素,会存到尾部位置,获取头部元素时,获取的是最后进入的那个元素.
队列比喻排队,遵循先进先出则.First In First Out.FIFO.
理解:从尾部进入元素,先进入的元素放在头部,获取头部时,获取的是先进来的那个元素.
3.LinkedList的特有方法: addFirst(E e) addLast(E e) getFirst() getLast()
removeFirst removeLast等等.
这些特有方法都是围绕头尾操作的方法.所以所有的方法都是围绕其特点定义的.
4.那么运用以上的特有方法,以及LinkedList的特点,就可以模拟堆栈和队列的数据结构了.

思路: 用LinkedList模拟一个堆栈或者队列数据结构。
1.需要先创建一个模拟的MyStack类,里面定义方法
2.MyStack类中定义堆栈结构存入元素的方法
3.MyStack类中定义堆栈结构取出元素的方法
4.MyStack类中定义堆栈结构中元素是否为空的方法
5.模拟堆栈结构,先进后出原则,首先需要先创建堆栈结构的对象实例
6.判断模拟的堆栈队列中是否还有元素,有则一直调用get方法,直到没有元素位置,
观察输出的结果是否符合堆栈数据结构的特点,先进后出.
7.创建MyQueue队列的类,里面定义队列的存储数据的方式,模拟队里的数据结构,方法同上.
*/

public class LinkedListTest {
    public static void main(String[] args) {
        //5.模拟堆栈结构,先进后出原则,创建堆栈结构的对象实例,操作,输出结果.
        MyStack stack = new MyStack();
        
        stack.add("one");
        stack.add("two");
        stack.add("three");
        stack.add("four");
        /*堆栈的数据结构获取顺序应该是
         four
         three
         two
         one
         */
        
        while(!stack.isEmpty()){
            System.out.println(stack.get());
        }
        
        System.out.println("--------分割线----------");
        //队列数据结构的模拟
        MyQueue queue = new MyQueue();
        
        queue.add("one");
        queue.add("two");
        queue.add("three");
        queue.add("four");
        
        /*队列的数据结构获取顺序应该是
         one
         two
         three
         four
         */
        while(!queue.isEmpty()){
            System.out.println(queue.get());
        }
        
        /*输出结果:
             four
            three
            two
            one
    --------分割线----------
            one
            two
            three
            four 
         * */
    }
}

View Code

/**
 *    定义自制堆栈数据结构
 *    模拟用  遵循先进后出
 */
public class MyStack {
    /*封装一个链表数据结构*/
    private LinkedList stack;
    
    /*注意:初始化MyStack
     * new一个链表数据结构的列表*/
    public MyStack(){
        stack = new LinkedList();
    }
    
    //模拟stack添加元素的方法(栈添加的是尾部的元素,也就是先进入的元素放在尾部)
    public void add(Object obj){
        stack.addFirst(obj);
        //注意:存入的元素顺序,每一个在下一个的前面位置存放.
    }

    //模拟stack获取元素的方法(栈获取的是头部的元素,也就是后入的元素)
    public Object get(){
        return stack.removeFirst();
        //注意1.因为是模拟堆栈,不能用LinkedList的get方法,那样不会移除头部的元素.
        //     2.移除的是每次头部的元素.根据上面add方法所述,即最后进入的元素在头部,所以会先移除.
        //     这样才符合栈的数据结构特点: 先进后出. 或者说后进先出.
    }
    
    //判断stack是否为空
    public boolean isEmpty(){
        return stack.isEmpty();
    }
}

View Code

/**
 *    定义自制队列数据结构
 *    模拟用  遵循先进后出
 */
public class MyQueue {
    /*封装一个链表数据结构*/
    private LinkedList queue;
    
    /*注意:初始化MyStack
     * new一个链表数据结构的列表*/
    public MyQueue(){
        queue = new LinkedList();
    }
    
    //模拟queue添加元素的方法(栈添加的是尾部的元素,也就是先进入的元素放在尾部)
    public void add(Object obj){
        queue.addFirst(obj);
        //注意:存入的元素顺序,每一个在下一个的前面位置存放.
    }

    //模拟queue获取元素的方法(栈获取的是尾部的元素,也就是先入的元素)
    public Object get(){
        return queue.removeLast();
        //注意1.因为是模拟队列,不能用LinkedList的get方法,那样不会移除头部的元素.
        //     2.移除的是每次尾部的元素.根据上面add方法所述,即最先进入的元素在尾部,所以会先移除.
        //     这样才符合栈的数据结构特点: 先进先出. 或者说后进后出.
    }
    
    //判断stack是否为空
    public boolean isEmpty(){
        return queue.isEmpty();
    }
}

View Code

 

转载于:https://www.cnblogs.com/zyjcxc/p/5452885.html