第二阶段-day02_Linked

今天我们主要将了数组和链表。

复习昨天

集合类：
    a.集合类可以自己调整大小
    b.只能存储引用类型的数据
    c.有丰富的API
    
Collection
    概述：
    API:
        增：
            boolean add(E e)
            boolean add(Collection c)
        删：
            void clear()
            boolean remove(Object o)
            boolean removeAll(Collection c)
            boolean retainAll(Collection c)
        查：
            boolean contains(Object o)
            boolean containsAll(Collection c)
        获取集合属性：
            int size()
            boolean isEmpty()
        遍历：
            Object[] toArray()
            Iterator iterator()

Iterator
    概述：
    设计原理：迭代器设计模式
    API:
        boolean hasNext()
        E next()
        void remove()
    注意事项：
        a. 警惕并发修改异常
        b. 用迭代器遍历的时候，不要使用while循环，可以使用for循环，最好使用foreach

List
    概述：
    API:
        增：
            void add(int index,E e)
            void addAll(int index, Collection c)
        删：
            E remove(int index)
        改：
            E set(int index, E e)
        查：
            E get(int index)
            int indexOf(Object o)
            int lastIndexOf(Object o)
        获取子串：
            List subList(int fromIndex, int toIndex)
        遍历：
            ListIterator listIterator()
            ListIterator listIterator(int index)

接着昨天的List讲

List subList(int fromIndex, int toIndex)：获取子串，左包右不包

package com.cskaoyan.list;

import java.util.ArrayList;
import java.util.List;

/*
 视图技术
 List subList(int fromIndex, int toIndex)
 */
public class ListDemo1 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");

        List subList = list.subList(1, 2);
        System.out.println(subList); //[world]

        subList.set(0, "WORLD");
        System.out.println(subList); //[WORLD]
        System.out.println(list);//[]
    }
}

List:
    ListIterator<E> listIterator()
    ListIterator<E> listIterator(int index)

package com.cskaoyan.list;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

/*
List:
    ListIterator<E> listIterator()
    ListIterator<E> listIterator(int index)

ListIterator接口
概述：列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。
API:
    遍历：
        boolean hasNext()
        E next()
        boolean hasPrevious()
        E previous()
    获取位置：
        int previousIndex()
        int nextIndex()
    修改列表：
        void add(E e)
        void remove()
        void set(E e)
 */
public class ListDemo2 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");

        // ListIterator it = list.listIterator();
        /*ListIterator it = list.listIterator(2);
        System.out.println(it.next()); //java*/

        // 正向遍历
        /*for(ListIterator it = list.listIterator(); it.hasNext(); ){
            String s = (String) it.next();// 为什么会报错呢？
            System.out.println(s);
        }*/

        // 逆向遍历
/*        for(ListIterator it = list.listIterator(list.size()); it.hasPrevious(); ) {
            String s = (String) it.previous();
            System.out.println(s);
        }*/

        // int previousIndex()
        // int nextIndex()
       /* ListIterator it = list.listIterator(1);
        // it.previous();
        it.next();
        it.next();
        System.out.println(it.previousIndex()); // 2
        System.out.println(it.nextIndex());// 3*/


       // void add(E e) 在哪个位置添加元素？光标后面
        /*ListIterator it = list.listIterator(2);
        it.add("HelloKitty");
        System.out.println(list);*/

        //练习：在world后面添加"HelloKitty"
        /*for(ListIterator it = list.listIterator(); it.hasNext(); ){
            String s = (String) it.next();
            // if ("world".equals(s)) it.add("HelloKitty");
            *//*if ("world".equals(s)) {
                int index = it.nextIndex();
                list.add(index, "HelloWorld");
            }*//*
        }
        System.out.println(list);*/

        //练习：在world前面添加"HelloKitty"
       /* for(ListIterator it = list.listIterator(list.size()); it.hasPrevious(); ) {
            String s = (String) it.previous();
            if ("world".equals(s)) it.add("HelloKitty");
        }
        System.out.println(list);*/

        // void remove() 删除哪个元素？删除的是最近返回的元素
        /*ListIterator it = list.listIterator();
        it.next();
        it.remove();
        System.out.println(list);*/

        /*ListIterator it = list.listIterator(list.size());
        it.previous();
        it.remove();
        System.out.println(list);*/

        // 如果最近没有返回元素，会怎样
        /*ListIterator it = list.listIterator();
        it.remove();*/ // IllegalStateException

        /*ListIterator it = list.listIterator();
        it.next();
        it.add("Allen");
        it.remove(); //IllegalStateException
        System.out.println(list);*/

        // 并发修改异常
        /*for(ListIterator it = list.listIterator(); it.hasNext();) {
            // if ("hello".equals(it.next())) it.remove();
            if ("hello".equals(it.next())) {
                int index = it.previousIndex();
                list.remove(index);
            }
        }
        System.out.println(list);*/

        // void set(E e) 替换哪个元素？最近返回的元素
        // 练习：把"java"替换成"javaSE"
        /*for(ListIterator it = list.listIterator(); it.hasNext();) {
            // if ("java".equals(it.next())) it.set("javaSE");
            if ("java".equals(it.next())) {
                int index = it.previousIndex();
                list.set(index, "javaSE");
            }
        }*/
        ListIterator it = list.listIterator();
        // it.set("javaSE"); // IllegalStateException
        it.next();
        it.remove();
        it.set("javaSE"); // IllegalStateException
        System.out.println(list);
    }
}

常见的数据结构

• 数组
• 链表
• 栈
• 队列
• 树
• 哈希表
• 图

数组

Q1: 数组我们都很熟悉，那你理解的数组是什么样的呢？它的最主要特点是什么呢？

Q2: 为什么数组的索引是一般都是从0开始的呢？

Q3: 为什么数组的效率比链表高？

 

Q1: 数组我们都很熟悉，那你理解的数组是什么样的呢？它的特点是什么呢？

A1:数组的本质是固定大小的连续的内存空间，并且这片连续的内存空间又被分割成等长的小空间。它最主要的特点是随机访问。

数组的长度是固定的
数组只能存储同一种数据类型的元素

注意：在Java中只有一维数组的内存空间是连续，多维数组的内存空间不一定连续。

那么数组又是如何实现随机访问的呢？

寻址公式：i_address = base_address + i * type_length

 

Q2: 为什么数组的索引是一般都是从0开始的呢？

假设索引不是从0开始的，而是从1开始的，那么我们有两种处理方式：

寻址公式变为： i_address = base_address + (i – 1) * type_length

浪费开头的一个内存空间，寻址公式不变。

在计算机发展的初期，不管是CPU资源，还是内存资源都极为宝贵，所以在设计编程语言的时候，索引就从0开始了，而我们也一直延续了下来。

 

Q3: 为什么数组的效率比链表高？

CPU、内存和IO设备，它们传输数据的速率是存在很大差异的。

那么根据木桶理论：木桶能装多少水，取决于最短的那块木板。程序的性能主要取决于IO设备的性能？也就是说，我们提升CPU和内存的传输速率收效甚微。

实际是这样的吗？当然不是！那我们是怎么解决它们之间的速率差异的呢？

CPU 和 内存
      高速缓存（预读）
      编译器的指令重排序

内存和 IO
      缓存：将磁盘上的数据缓存在内存。

CPU 和 IO
      中断技术
     
数组可以更好地利用CPU的高速缓存！

 

数组的基本操作

 

 

总结: 数组增删慢，查找快。

 

链表

形象地说，链表就是用一串链子将结点串联起来。

结点：包含数据域和指针域。
数据域：数据
指针域：下一个结点的地址

 

 

　　结点    

　　链表   

 链表的分类：

循环链表我们用的一般比较少，但是当处理的数据具有环形结构时，就特别适合用循环链表，比如约瑟夫问题。接下来我们讨论下单链表和双向链表。

单链表：

 总结：链表增删快，查找慢。

双向链表：

很容易验证，前面那些操作，双向链表和单链表的时间复杂度是一样的。那为什么在工程上，我们用的一般是双向链表而不是单链表呢 (比如JDK中的 LinkedList & LinkedHashMap)？

那自然是双向链表有单链表没有的独特魅力——它有一条指向前驱结点的链接。

总结：虽然双向链表更占用内存空间，但是它在某些操作上的性能是优于单链表的。

思想：用空间换取时间。

缓存就是一种用空间换取时间的技术。

内存大小是有限的，所以缓存不能无限大。那么当缓存满的时候，再向缓存中添加数据，该怎么办呢？

缓存淘汰策略：
         ① FIFO (First In First Out)
         ② LFU (Least Frequently Used)
         ③ LRU (Least Recently Used)

 

LRU算法中我们就用到了链表！

练习：

1. 求链表的中间元素
2. 判断链表中是否有环
3. 反转单链表

package com.cskaoyan.exercise;

public class Node {
    int value;
    Node next;

    public Node(int value) {
        this.value = value;
    }

    public Node(int value, Node next) {
        this.value = value;
        this.next = next;
    }
}

1.求链表的中间元素

package com.cskaoyan.exercise;
/*
求链表的中间元素
示例：
输入：1 --> 2 --> 3
输出：2
输入：1 --> 2 --> 3 --> 4
输出：2

Q1：如果是数组，我们可以求中间元素？
arr[(arr.length-1) / 2]
Q2:
    1.先求得长度length
    2.再从头开始遍历，一边遍历，一边计算当前结点得索引。
      当索引为 (length-1)/2 时，返回这个结点的值。
 */
public class Ex1 {
    public static int middleElement(Node head) {
        // 求链表的长度
        int length = 0;
        Node x = head;
        while (x != null) {
            length++;
            x = x.next; //x指向下一个结点
        }
        // 从头开始遍历，找索引为 (length-1)/2 的结点
        int index = 0;
        x = head;
        while (index < (length - 1) / 2) {
            index++;
            x = x.next;
        }
        return x.value;
    }

    public static void main(String[] args) {
        // 1 --> 2 --> 3
        /*Node head = new Node(3);
        head = new Node(2, head);
        head = new Node(1, head);
        System.out.println(middleElement(head));*/

        // 1 --> 2 --> 3 --> 4
/*        Node head = new Node(4);
        head = new Node(3, head);
        head = new Node(2, head);
        head = new Node(1, head);
        System.out.println(middleElement(head));*/
    }
}

2.判断链表中是否有环

package com.cskaoyan.exercise;
/*
判断链表中是否有环
1. 给一个阈值（10ms）,如果在遍历链表的过程中10ms还没有结束，就认为有环。
2. 迷雾森林
   Collection visited = new ArrayList();
 */
public class Ex2 {
    public static boolean hasCircle(Node head) {

    }
}