数据结构 第3章 笔记与总结

3.1 抽象数据类型 abstract data type

ADT = 数据结构 + 操作

3.2 表ADT

3.2.1 表的简单数组实现

数组 arr 在必要时候被扩展

int[] arr = new int[10];
...
// 扩大arr
int[] newArr = new int[arr.length * 2];
for(int i = 0; i < arr.length; i++)
    newArr[i] = arr[i];
arr = newArr;

 

3.2.2 简单链表

3.3 Java Collections API 中的表

3.3.1 Collections 接口

Collections API位于java.util包中。集合的概念在Collections接口中得到抽象，它存储一组类型相同的对象。下面显示该接口一些最重要的部分（一些方法未被显示）

public interface Collections<AnyType> extends Iterable<AnyType> 
{　　
　　int size();
    boolean isEmpty();
    void clear();
    boolean contains(AnyType x);
    boolean add(AnyType x);
    boolean remove(AnyType x);
    java.util.Iterator<AnyType> iterator();
}

Collection接口继承了Iterable接口。实现了Iterable接口的类可以拥有增强的for循环。如下：

public static<AnyType> void print(Collection<AnyType> coll){
　　for(AnyType item : coll)
    　　System.out.println(item);
}

3.3.2 Iterator接口

实现Iterable接口的集合必须提供一个iterator方法，该方法返回一个实现了Iterator接口的对象。该Iterator是在java.util包中定义的接口。

public interface Iterator<AnyType>
{
    boolean hasNext( );
    AnyType next( );
    void remove( );
}

【xyl整理思路】

Collection接口扩展了Iterable接口，实现了Iterable接口的集合必须要提供一个iterator方法，这个方法返回一个实现了Iterator接口的对象。【从下面代码的角度更好理解这段话】

public static <AnyType> void print( Collection<AnyType> coll ) 
{
    Iterator<AnyType> itr = coll.iterator( ); 
    while( itr.hasNext( ) ) {
        AnyType item = itr.next( ); 
        System.out.println( item );
    }     
}        

Iterator接口的remove方法：
可以删除由next最近返回的项（删除一次后，我们不能再调用remove，只有再对next调用一次后才可以remove）

Iteraror的remove方法和Collection的remove方法：
Iterator的remove方法的优点：
1、Collection的remove方法必须首先找出要被删除的项。
2、使用Iterator的一个基本法则：如果对正在被迭代的集合进行结构上的改变（即add、remove、clear方法），那么迭代器不再合法。Iterator的remove的方法除外。

 

3.3.3 List 接口、ArrayList 类和LinkedList 类

List 接口继承了 Collection 接口，它包含Collection接口的所有方法。下面解释了其中一些重要方法：

public interface List<AnyType> extends Collection<AnyType> {
    AnyType get( int idx );
    AnyType set( int idx, AnyType newVal ); 
    void add( int idx, AnyType x ); 
    void remove( int idx );

    ListIterator<AnyType> listIterator( int pos ); 
}

List 接口指定 listIterator 方法，它将产生比通常更复杂的迭代器，在 3.3.5 补充。

List ADT 有两种常见实现方式：1、ArrayList 类；2、LinkedList 类。

ArrayList 类

提供了 List ADT 的一种可增长数组的实现。

LinkedList 类

提供了 List ADT 的双链表实现。

本小节重点在于两者的区别：

ArrayList 类：查找快，增删慢；
LinkedList 类：增删快，查找慢。

 

3.3.4 例子：remove 方法对 LinkedList 类的使用

Iterator 接口的remove 方法，只花费线性时间。

public static void removeEvensVer3( List<Integer> lst ) {
    Iterator<Integer> itr = lst.iterator( ); 

    while( itr.hasNext( ) )
    if( itr.next( ) % 2 == 0 ) 
        itr.remove( );
}    

 

3.3.5 关于 ListIterator 接口

下面代码展示了 ListIterator 继承了  List 的 Iterator 的功能。方法 previous 和 hasPrevious 可以实现表从后向前的遍历。add 方法将一个新的项以当前位置放入表中。

public interface ListIterator<AnyType> extends Iterator<AnyType> {
　　boolean hasPrevious( ); 
　　AnyType previous( );
　　
　　void add( AnyType x ); 
　　void set( AnyType newVal ); 
}

 

3.4 ArrayList 类的实现

3.4.1 基本类

public class MyArrayList<AnyType> implements Iterable<AnyType> {
        private static final int DEFAULT_CAPACITY = 10;
        private int theSize;
        private AnyType[] theItems;

        public MyArrayList() {
            doClear();
        }

        public void clear() {
            doClear();
        }

        private void doClear() {
            theSize = 0;
            ensureCapacity(DEFAULT_CAPACITY);
        }

        public int size() {
            return theSize;
        }

        public boolean isEmpty() {
            return size() == 0;
        }

        public void trimToSize() {
            ensureCapacity(size());
        }

        public AnyType get(int idx) {
            if (idx < 0 || idx >= size()) throw new ArrayIndexOutOfBoundsException();
            return theItems[idx];
        }

        public AnyType set(int idx, AnyType newVal) {
            if (idx < 0 || idx >= size())
                throw new ArrayIndexOutOfBoundsException();
            AnyType old = theItems[idx];
            theItems[idx] = newVal;
            return old;
        }

        public void ensureCapacity(int newCapacity) {
            if (newCapacity < theSize) return;
            AnyType[] old = theItems;
            theItems = (AnyType[]) new Object[newCapacity];
            for (int i = 0; i < size(); i++) theItems[i] = old[i];
        }

        public boolean add(AnyType x) {
            add(size(), x);
            return true;
        }

        public void add(int idx, AnyType x) {
            if (theItems.length == size())
                ensureCapacity(size() * 2 + 1);
            for (int i = theSize; i > idx; i--) theItems[i] = theItems[i - 1];
            theItems[idx] = x;
            theSize++;
        }

        public AnyType remove(int idx) {
            AnyType removedItem = theItems[idx];
            for (int i = idx; i < size() - 1; i++) theItems[i] = theItems[i + 1];
            theSize--;
            return removedItem;
        }

        public java.util.Iterator<AnyType> iterator() {
            return new ArrayListIterator();
        }

        private class ArrayListIterator implements java.util.Iterator<AnyType> {
            private int current = 0;

            public boolean hasNext() {
                return current < size();
            }

            public AnyType next() {
                if (!hasNext())
                    throw new java.util.NoSuchElementException();
                return theItems[current++];
            }

            public void remove() {
                MyArrayList.this.remove(--current);
            }
        }
    }

 

ArrayListIterator 这里有一个 Java 结构，它是 MyArrayList 的内部类。

 

下面则是 嵌套类

public class MyArrayList<AnyType> implements Iterable<AnyType> {
        private int theSize;
        private AnyType[] theItems; ...

        public java.util.Iterator<AnyType> iterator() {
            return new ArrayListIterator<AnyType>(this);
        }

        private static class ArrayListIterator<AnyType> implements java.util.Iterator<AnyType> {
            private int current = 0;
            private MyArrayList<AnyType> theList; ...

            public ArrayListIterator(MyArrayList<AnyType> list) {
                theList = list;
            }

            public boolean hasNext() {
                return current < theList.size();
            }

            public AnyType next() {
                return theList.theItems[current++];
            }
        }
    }

 

嵌套类和内部类的区别是，必须使用 static 来表示是嵌套的；没有 static 则是内部类。

嵌套类可以被设计成 private

 

补充知识：内部类、外部类

内部类：类的第五个成员
1.定义：Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类.
2.内部类的分类：
成员内部类（静态、非静态 ） vs 局部内部类(方法内、代码块内、构造器内)
3.成员内部类的理解：
一方面，作为外部类的成员：
调用外部类的结构
可以被static修饰（嵌套类）
可以被4种不同的权限修饰

另一方面，作为一个类：
类内可以定义属性、方法、构造器等
可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
可以被abstract修饰
4.成员内部类：
4.1如何创建成员内部类的对象？(静态的，非静态的)

//创建静态的Dog内部类的实例(静态的成员内部类):
Person.Dog dog = new Person.Dog();

//创建非静态的Bird内部类的实例(非静态的成员内部类):
//Person.Bird bird = new Person.Bird();//错误的
Person p = new Person();
Person.Bird bird = p.new Bird();

4.2如何在成员内部类中调用外部类的结构？⭐

public class Person {
    String name = "小明";
    public void eat(){
    }
    //非静态成员内部类
    class Bird{
        String name = "杜鹃";
        public void display(String name){
            System.out.println(name);//方法的形参
            System.out.println(this.name);//内部类的属性
            System.out.println(Person.this.name);//外部类的属性
            //Person.this.eat();
        }
    }  
}

5.局部内部类的使用：

//返回一个实现了Comparable接口的类的对象
    public Comparable getComparable(){

        //创建一个实现了Comparable接口的类:局部内部类
        //方式一：
//        class MyComparable implements Comparable{
//
//            @Override
//            public int compareTo(Object o) {
//                return 0;
//            }           
//        }       
//        return new MyComparable();

        //方式二：
        return new Comparable(){

            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }

 

注意点：
在局部内部类的方法中（比如：show如果调用局部内部类所声明的方法(比如：method)中的局部变量(比如：num)的话,要求此局部变量声明为final的。

jdk 7及之前版本：要求此局部变量显式的声明为final的
jdk 8及之后的版本：可以省略final的声明
总结：
成员内部类和局部内部类，在编译以后，都会生成字节码文件。
格式：成员内部类：外部类$内部类名.class
局部内部类：外部类$数字 内部类名.class

3.5 LinkedList 类的实现

public class MyLinkedList<AnyType> implements Iterable<AnyType> {
    private static class Node<AnyType> {/* Figure 3.25 */
    }

    public MyLinkedList() {
        doClear();
    }

    public void clear() {/* Figure 3.26 */}

    public int size() {
        return theSize;
    }

    public boolean isEmpty() {
        return size() == 0;
    }

    public boolean add(AnyType x) {
        add(size(), x);
        return true;
    }

    public void add(int idx, AnyType x) {
        addBefore(getNode(idx, 0, size()), x);
    }

    public AnyType get(int idx) {
        return getNode(idx).data;
    }

    public AnyType set(int idx, AnyType newVal) {
        Node<AnyType> p = getNode(idx);
        AnyType oldVal = p.data;
        p.data = newVal;
        return oldVal;
    }

    public AnyType remove(int idx) {
        return remove(getNode(idx));
    }

    private void addBefore(Node<AnyType> p, AnyType x) {/* Figure 3.28 */}

    private AnyType remove(Node<AnyType> p) {/* Figure 3.30 */}

    private Node<AnyType> getNode(int idx) {/* Figure 3.31 */}

    private Node<AnyType> getNode(int idx, int lower, int upper) {/* Figure 3.31 */}

    public java.util.Iterator<AnyType> iterator() {
        return new LinkedListIterator();
    }

    private class LinkedListIterator implements java.util.Iterator<AnyType> {/* Figure 3.32 */
    }

    private int theSize;
    private int modCount = 0;
    private Node<AnyType> beginMarker;
    private Node<AnyType> endMarker;
}

 

MyLinkedList 类的嵌套 Node 类

private static class Node<AnyType> {
    public Node(AnyType d, Node<AnyType> p, Node<AnyType> n) {
        data = d;
        prev = p;
        next = n;
    }

    public AnyType data;
    public Node<AnyType> prev;
    public Node<AnyType> next;
}

 

MyLinkedList 类的 clear 例程

public void clear(){
    doClear();
}
private void doClear(){
    beginMarker = new Node<AnyType>(null,null,null);
    endMarker = new Node<AnyType>(null,beginMarker,null);
    beginMarker.next = endMarker;
    
    theSize=0;
    modCount++;
}

 

MyLinkedList 类的 add 例程

/**
 * Adds an item to this collection, at specified position p. 
 * Items at or after that position are slid one position higher.
 * @param p Node to add before. 
 * @param x any object.
 * @throws IndexOutOfBoundsException if idx is not between 0 and size(),.
 */
private void addBefore(Node<AnyType> p, AnyType x) {
    Node<AnyType> newNode = new Node<>(x, p.prev, p);
    newNode.prev.next = newNode;
    p.prev = newNode;
    theSize++;
    modCount++;
}

 

MyLinkedList 类的 remove 例程

MyLinkedList 类的 getNode 例程

MyLinkedList 类的的内部 Iterator 类

3.6 栈 ADT