zoukankan      html  css  js  c++  java
  • List容器——LinkedList及常用API,实现栈和队列

    LinkedList及常用API

    ①   LinkedList----链表

    ②   LinkedList类扩展AbstractSequentialList并实现List接口

    ③   LinkedList提供了一个链表数据结构

    ④   LinkedList有两个构造方法

    a)   LinkedList()

    b)   LinkedList(Collection c)

    ⑤   除了继承的方法之外,LinkedList类还定义了一些有用的方法用于操作和访问容器中的数据;

    a)   void addFirst(E e)

    b)   void addLast(E e)

    c)    E removeFirst()

    d)    E removeLast()

     1 LinkedList<String> sList = new LinkedList<String>();
     2         sList.add("zhangsan");// 将指定元素添加到此列表的结尾
     3         sList.add("lisi");
     4         sList.add("wangwu");
     5         sList.add("rose");
     6         sList.add("mary");
     7         sList.add("jack");
     8         sList.addFirst("jay");// 将指定元素插入此列表的开头
     9         sList.addLast("jhon");// 将指定元素添加到此列表的结尾
    10         for (String name : sList) {
    11             System.out.println(name);
    12         }
    13         
    14         System.out.println("****************************************");
    15         System.out.println(sList.removeFirst());//移除并返回此列表的第一个元素;如果此列表为空,NoSuchElementException 
    16         sList.clear();
    17         System.out.println(sList.size());//返回此列表的元素数
    18         System.out.println(sList.pollFirst());//获取并移除此列表的第一个元素;如果此列表为空,则返回 null

    Linked中链表结构如下:

    LinkedList中的 remove(Object)方法如下:

     1  public boolean remove(Object o) {
     2         if (o == null) {
     3             for (Node<E> x = first; x != null; x = x.next) {
     4                 if (x.item == null) {
     5                     unlink(x);
     6                     return true;
     7                 }
     8             }
     9         } else {
    10             for (Node<E> x = first; x != null; x = x.next) {
    11                 if (o.equals(x.item)) {
    12                     unlink(x);
    13                     return true;
    14                 }
    15             }
    16         }
    17         return false;
    18     }

    再找到unlink方法

     1 E unlink(Node<E> x) {
     2         // assert x != null;
     3         final E element = x.item;
     4         final Node<E> next = x.next;
     5         final Node<E> prev = x.prev;
     6 
     7         if (prev == null) {
     8             first = next;
     9         } else {
    10             prev.next = next;
    11             x.prev = null;
    12         }
    13 
    14         if (next == null) {
    15             last = prev;
    16         } else {
    17             next.prev = prev;
    18             x.next = null;
    19         }
    20 
    21         x.item = null;
    22         size--;
    23         modCount++;
    24         return element;
    25 }

    从中可以看到删除时做的操作是,将要删除的元素b设为null,并且将其上一个元素a指向b的下一个元素c,将c指向a;

    总结:

    内部封装的是双向链表数据结构

    每个节点是一个Node对象,Node对象中封装的是你要添加的元素

    还有一个指向上一个Node对象的引用和指向下一个Node对象的引用

               

    不同的容器有不同的数据结构,不同的数据结构操作起来性能是不同的

    链表数据结构,做插入,删除的效率比较高,但查询效率比较低

                

    数组结构,它做查询的效率高,因为可以通过下标直接找到元素

    但插入删除效率比较低,因为要做移位操作

     

     

    二:用LinkedList实现栈和队列

    栈的特点,后进先出

               

    栈的方法:

     1 class MyStack<T>{
     2     private LinkedList<T> data=null;
     3     public MyStack() {
     4         data=new LinkedList<T>();
     5     }
     6 
     7     //压栈的方法
     8     public void push(T obj) {
     9         data.addFirst(obj);
    10     }
    11     
    12     public T pop() {
    13         return data.removeFirst();
    14     }
    15     
    16     public  Iterator<T> iterator() {
    17         return data.iterator();
    18     }
    19 }

    main函数中添加及使用:

     1 MyStack<String> mystack=new MyStack<String>();
     2         mystack.push("zhangsan");
     3         mystack.push("lisi");
     4         mystack.push("wangwu");
     5         mystack.push("zhaoliu");
     6         mystack.pop();
     7         mystack.pop();
     8          Iterator<String> it=mystack.iterator();
     9          while(it.hasNext()){
    10              System.out.println(it.next());
    11          }

    输出结果:

    lisi

    zhangsan

    队列的特点:先进先出

    队列的方法:

     1 class myQueue<T>{
     2     private LinkedList<T> data=null;
     3     public myQueue(){
     4         data=new LinkedList<T>();
     5     }
     6     
     7     public void push(T obj) {
     8         data.addFirst(obj);
     9     }
    10     
    11     public T pop() {
    12         return data.removeLast();
    13     }
    14     
    15     public Iterator<T> iterotor() {
    16         return data.iterator();
    17     }
    18 }

    main函数中添加及使用:

     1 myQueue<Integer> myQueue=new myQueue<Integer>();
     2         myQueue.push(1);
     3         myQueue.push(2);
     4         myQueue.push(3);
     5         myQueue.push(4);
     6         myQueue.push(5);
     7         myQueue.pop();
     8         myQueue.pop();
     9         Iterator<Integer> it= myQueue.iterotor();
    10         while (it.hasNext()) {
    11             System.out.println(it.next());
    12         }

    输出结果:

    5

    4

    3

  • 相关阅读:
    Atitit 华为基本法 attilax读后感
    Atitit 华为管理者内训书系 以奋斗者为本 华为公司人力资源管理纲要 attilax读后感
    Atitit 项目版本管理gitflow 与 Forking的对比与使用
    Atitit 管理的模式扁平化管理 金字塔 直线型管理 垂直管理 水平管理 矩阵式管理 网状式样管理 多头管理 双头管理
    Atitit 乌合之众读后感attilax总结 与读后感结构规范总结
    深入理解 JavaScript 异步系列(4)—— Generator
    深入理解 JavaScript 异步系列(3)—— ES6 中的 Promise
    深入理解 JavaScript 异步系列(2)—— jquery的解决方案
    深入理解 JavaScript 异步系列(1)——基础
    使用 github + jekyll 搭建个人博客
  • 原文地址:https://www.cnblogs.com/wzy330782/p/5384984.html
Copyright © 2011-2022 走看看