Java: LinkedListDemo学习----2020.3.5

package ListDemo;

import java.util.*;
/*
//linkedList它内部封装的是双向链表数据结构
//每个节点是一个Node对象，Node对象中封装的是你要添加的元素，还有一个指向上一个Node对象的应用和指向下一个Node对象的引用
//不同的容器有不同的数据结构，不同的数据结果操作起来性能不同
//链表数据结构，做插入和删除的效率比较高，但查询效率低。
//数组数据结构，做查询的效率高，因为可以通过下标来直接找到元素，但插入和删除效率比较低，因为要做移位操作
 */

public class LinkedListDemo1 {

    public static void main(String[] args) {

        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("zhangsan");
        linkedList.add("yangyang");
        linkedList.add("mama");
        linkedList.add("baba");
        linkedList.addFirst("chengguo");//添加在第一个位置
        linkedList.addLast("laoyao");//添加在最后一个位置
        //遍历
        Iterator<String> it = linkedList.iterator();
        while (it.hasNext()) {
            String name = it.next();
            System.out.println(name);
        }
        System.out.println("遍历2：");
        //遍历2
        for (Iterator<String> itt = linkedList.iterator(); itt.hasNext(); ) {
            String name = itt.next();
            System.out.println(name);
        }
        System.out.println("遍历3：");
        //遍历3：增强for循环
        for (String s : linkedList) {
            System.out.println(s);
        }
        System.out.println("测试其他方法");
        //linkedList.clear();
        System.out.println(linkedList.removeFirst());//把第一个删除,当链表为null时，这个方法抛出异常
        System.out.println(linkedList.size());//5
        linkedList.clear();
        System.out.println(linkedList.pollFirst());//把新的第一个删除,当链表为null时，这个方法返回null
        System.out.println(linkedList.size());//4
    }
}



2、利用LinkedList实现栈和队列

package ListDemo;

import java.util.*;
public class LinkedListDemo2 {
    public static void main(String[] args){
        //实现栈，后进先出
        MyStack<String> myStack=new MyStack<>();
        myStack.push("zhangsan");
        myStack.push("wangqiu");
        myStack.push("wangwu");
        System.out.println(myStack.pop());
        System.out.println(myStack.pop());
        Iterator<String> it=myStack.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        //zhangsan，先进后出


        System.out.println("实现队列：先进先出");

        MyQueue<Integer> myQueue=new MyQueue<>();
        myQueue.push(1);
        myQueue.push(2);
        myQueue.push(3);
        myQueue.push(4);
        myQueue.push(5);
        myQueue.pop();
        myQueue.pop();
        Iterator<Integer> it2=myQueue.iterator();
        while(it2.hasNext()){
            System.out.println(it2.next());
        }
        //1，2出去了，先进先出


    }
}

class MyStack<T>{
    private LinkedList<T> data=null;
    public MyStack(){
        data=new LinkedList<>();
    }
    //压栈
    public void push(T obj){
        data.addLast(obj);
    }
    //出栈
    public T pop(){
        return data.removeLast();
    }
    //遍历
    public Iterator<T> iterator(){
        return data.iterator();
    }


}

class MyQueue<T>{
    private LinkedList<T> data=null;
    public MyQueue(){
        data=new LinkedList<>();
    }
    //入队
    public void push(T obj){
        data.addLast(obj);
    }
    //出队
    public T pop(){
        return data.removeFirst();
    }
    //遍历
    public Iterator<T> iterator(){
        return data.iterator();
    }
}