Java数据结构基础——实现线性表和链表

1. 引言

通过接口MyList定义通用功能，抽象类MyAbstractList实现部分功能，MyArrayList和MyLinkedList实现类分别实现数组线性表和链表的方式进一步理解线性表。

2. 线性表的通用特性

线性表是一个顺序存储数据的数据结构，并提供增删改查的操作。实现线性表的方式有两种。

• 使用数组(array)存储线性表的元素，数组大小是固定的，如果数组元素超过了数组容量就会创建一个更大的数组，并将当前元素复制到新数组中
• 使用链式结构(linked structure)。链式结构由结点组成，每个结点都是动态创建的，用来存储一个元素。

一个好的设计策略就是在设计中提供接口和便利抽象类，以整合接口和抽象类的优点，抽象类提供了接口的骨架实现，用户可以认为哪个方便就用哪个。如下定义了MyArrayList和MyLinkedList通用接口。

2.1 MyList<E>接口

package myList.arrayList;
/*
 * 18.7.21
 * 这个是基础的接口定义，首先实现基本的增删改次功能，以及判断是否为空，线性表大小
 */
public interface MyList<E> extends Iterable<E> {

  public void add(E e);

  public void add(int index, E d);

  public void clear();

  //删除第一个匹配的元素，并将所有后面的元素左移
  public boolean remove(E e);

  //返回删除元素，并将所有元素左移
  public E remove(int index);

  //修改特定位置的元素，并返回原理的元素
  //之所以是object类型的是因为，原来的元素不一定和当前元素同一类型
  public Object set(int index, E e);

  //如果不包含返回-1
  public int indexOf(E e);

  public int lastIndexOf(E e);

  public E get(int index);

  public boolean contains(E e);

  public boolean isEmpty();

  public int size();
}

2.2 MyAbstractList<E>抽象类

MyAbstractList提供了MyList部分接口的实现，作为一个常用规则，可以将抽象类的数据域声明为被保护的，只有子类可以访问。

package myList.arrayList;
/*
 * 18.7.21
 * 线性表实现练习，定义抽象类实现部分方法，
 * isEmpty,size,add(E),remove(E)
 */

public abstract class MyAbstractList<E> implements MyList<E> {
  protected int size = 0;

  //抽象类的构造方法必须是protect类型，由子类继承实现，本身不能实例化
  protected MyAbstractList() {

  }

  protected MyAbstractList(E[] objects) {
    for(int i = 0; i < objects.length; i++) {
      add(objects[i]);
    }
  }

  @Override
  public void add(E e) {
    add(size,e);
  }

  @Override
  public int size() {
    return size;
  }

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

  @Override
  public boolean remove(E e) {
    if(indexOf(e) >= 0) {
      remove(indexOf(e));
      return true;
    }
    else
      return false;
  }

}

3. 数组线性表

数组线性表采用数组实现，数组一旦被创建其大小是固定的，但是仍然可以通过创建更大的数组来替换当前数组实现动态的数据结构。数组类型是E[]，数组中每个元素实际存储的是对象的引用。

3.1 MyArrayList<E>实现类

package myList.arrayList;
/*
 * 18.7.22
 * 数组线性表的类实现，由于部分实现在抽象类中实现了，所以
 * 有一部分方法不在这里。
 * 
 * 基本思想：
 * 在数组的基础上实现增删改查，初始化一个大小为16位的范型数组
 * 同时要时刻确保数组的size不会越界。
 */
import java.util.Iterator;

public class MyArrayList<E> extends MyAbstractList<E> {

  public static final int INITIAL_CAPACITY = 16;
  //由于范型消除，不能直接使用new E[INITIAL_CAPACITY]而是使用了类型转换
  private E[] data = (E[]) new Object[INITIAL_CAPACITY];

  public MyArrayList() {

  }

  public MyArrayList(E[] e) {
    for(int i = 0; i < e.length; i++) {
      add(e[i]);
    }
  }

  //确定数组的size在执行add操作后不会越界
  private void ensureCapacity() {
    if(size >= data.length) {
      E[] newData = (E[])new Object[2 * size + 1];
      System.arraycopy(data, 0, newData, 0, size);
      data = newData;
    }
  }

  @Override
  public void add(int index, E d) {
    ensureCapacity();
    //将index之后的元素右移
    for(int i = size - 1; i >= index; i--)
      data[i + 1] = data[i];

    data[index] = d;

    size++;
  }

  @Override
  public void clear() {
    data = (E[])new Object[INITIAL_CAPACITY];
    size = 0;
  }

  //判断下标是否越界
  private void checkIndex(int index) {
    if(index < 0 || index >= size) {
      throw new IndexOutOfBoundsException("index" 
      + index + " out of bounds");
    }
  }

  @Override
  public E remove(int index) {
    checkIndex(index);

    E e = data[index];
    //将index后面的元素左移
    for(int i = index; i < size - 1; i++)
      data[i] = data[i + 1];
    //注意最后一个元素现在为空
    data[size - 1] = null;
    size--;
    return e;
    }

  @Override
  public E set(int index, E e) {
    checkIndex(index);
    E old = data[index];
    data[index] = e;
    return old;
  }

  @Override
  public E get(int index) {
    checkIndex(index);
    return data[index];
  }

  //返回第一个匹配的元素下标，没有的话返回-1
  @Override
  public int indexOf(E e) {
    for(int i = 0;i < size; i++) {
      if(data[i] == e)
        return i;
    }
    return -1;
  }

  //返回最后一个匹配的元素下标，没有的话返回-1
  @Override
  public int lastIndexOf(E e) {
    for(int i = size-1; i >= 0; i--) {
      if(data[i] == e)
        return i;
    }
    return -1;
  }

  @Override
  public boolean contains(E e) {
    for(int i = 0;i < size; i++) {
      if(data[i] == e)
        return true;
    }
    return false;
  }

  //StringBuilder比String性能更好，StringBuffer线程安全
  @Override
  public String toString() {
    StringBuilder result = new StringBuilder("[");
    for(int i = 0; i < size; i++) {
      result.append(data[i]);
      if(i < size - 1)result.append(",");
    }
    result.append("]");
    return result.toString();
  }

  //将数组大小调整到合适
  public void trimToSize() {
    if(size != data.length) {
      E[] newData = (E[])(new Object[size]);
      System.arraycopy(data, 0, newData, 0, size);
      data = newData;
    }
  }

  @Override
  public Iterator<E> iterator() {
    return new ArrayListIterator();
  }

  //迭代器是从头开始的，所以初始值为0
  private class ArrayListIterator implements Iterator<E>{

    private int current = 0;

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

    @Override
    public E next() {
      return(data[current++]);
    }

    @Override
    public void remove() {
      //当在一个类的内部类中，如果需要访问外部类的方法或者成员域
      //就要必须使用  外部类.this.成员域
      MyArrayList.this.remove(current);
    }
  }
}

3.2 MyArrayList测试类

package myList.arrayList;

public class ArrayListMain {
  public static void main(String[] args) {
    MyArrayList<String> list = new MyArrayList<>();
    list.add("America");
    System.out.println("1 " + list);

    list.add(0, "Canada");
    System.out.println("2 " + list);

    list.add("Russia");
    System.out.println("3 " + list);

    list.add("France");
    System.out.println("4 " + list);

    list.add(2, "Germany");
    System.out.println("5 " + list);

    list.add(5, "Norway");
    System.out.println("6 " + list);

    list.remove("Canada");
    System.out.println("7 " + list);

    list.remove(2);
    System.out.println("8 " + list);

    list.remove(list.size - 1);
    System.out.print("9 " + list + "\n10 ");

    for(String s : list) {
      System.out.print(s.toUpperCase() + " ");
    }
  }
}


/* 
* 1 [America]
* 2 [Canada,America]
* 3 [Canada,America,Russia]
* 4 [Canada,America,Russia,France]
* 5 [Canada,America,Germany,Russia,France]
* 6 [Canada,America,Germany,Russia,France,Norway]
* 7 [America,Germany,Russia,France,Norway]
* 8 [America,Germany,France,Norway]
* 9 [America,Germany,France]
* 10 AMERICA GERMANY FRANCE 
*/

4. 链表

为了提高在头尾添加和删除元素的效率，可以采用链式结构来实现线性表，链表中每个元素都包含一个称为结点(node)的结构，结点可以按如下方式实现

public class Node<E>{
  public E element;
  Node<E> next;

  public Node(E e){
    element = e;
  }
}

4.1 接口和抽象类

链表的接口和抽象函数与数组线性表的结构相同，可以参考前半部分。

4.2 MyLinkedList实现类

package myList.linkedList;
/*
 * 18.7.23
 * 实现链表练习，继承自相同接口和抽象类，新添加的方法包括
 * addFirst、addLast、removeFirst、removeLast、getFirst、getLast
 * 按照增删改查的顺序实现方法
 */
import java.util.Iterator;

public class MyLinkedList<E> extends MyAbstractList<E> {

  private static class Node<E>{
    E element;
    Node<E> next;
    public Node(E e) {
      element = e;
    }      
  }

  private Node<E> head,tail;

  public MyLinkedList() {

  }

  public MyLinkedList(E[] object) {
    super(object);
  }

  @Override
  public void add(int index, E e) {
    if(index <= 0) addFirst(e);
    else if(index >= size) addLast(e);
    else {
      Node<E> current = head;
      //指向index的前一个元素
      for(int i = 1; i < index; i++) {
        current = current.next;
      }
      //将原来的元素存在临时结点
      Node<E> temp = current.next;
      //存储新的结点
      current.next = new Node<E>(e);
      //拼接原来的结点
      current.next.next = temp;
      size++;
    }
  }

  //增加头结点
  public void addFirst(E e) {
    Node<E> newNode = new Node<>(e);
    newNode.next = head;
    head = newNode;
    size++;
    //当只有一个结点的情况
    if(tail == null)
      tail = head;
  }

  //增加尾结点
  public void addLast(E e) {
    Node<E> newNode = new Node<>(e);
    //空结点的情况
    if(tail == null) {
      head = tail = newNode;
    } 
    else {
      tail.next = newNode;
      tail = tail.next;
    }
    size++;
  }

  //清楚元素
  @Override
  public void clear() {
    size = 0;
    head = tail = null;
  }

  //删除头结点
  public E removeFirst() {
    if(size == 0)return null;
    else {
      Node<E> temp = head;
      head = head.next;
      //当链表只有一个元素时的情况
      if(head == null)tail = null;
      size--;
      return temp.element;
    }
  }

  //删除尾结点
  public E removeLast() {
    if(size == 0)return null;
    else if (size == 1) {
      Node<E> temp = head;
      head = tail = null;
      size--;
      return temp.element;
    }
    else {
      Node<E> current = head;
      //指向尾结点之前的元素
      for(int i = 0; i < size - 2; i++) {
        current = current.next;
      }
      Node<E> temp = tail;
      tail = current;
      tail.next = null;
      size--;
      return temp.element;
    }
  }

  @Override
  public E remove(int index) {
    if(index < 0 || index >= size)return null;
    else if(index == 0)return removeFirst();
    else if(index == size - 1)return removeLast();
    else {
      Node<E> previous = head;
      //此处的i=1意为从index为2开始采用这个循环才有意义
      //得到的元素是索引之前的结点
      for(int i = 1; i < index; i++) {
        previous = previous.next;
      }
      //得到索引结点
      Node<E> current = previous.next;
      //删除索引结点
      previous.next = current.next;
      size--;
      return current.element;
    }
  }

  @Override
  public Object set(int index, E e) {
    if(index < 0 || index > size-1)return null;
    else {
      Node<E> current = head;
      for(int i = 0; i < index; i++) {
        current = current.next;
      }
      current.element = e;
      return current.element;
    }
  }

  //返回第一个符合条件的结点，没有则返回-1
  @Override
  public int indexOf(E e) {
    Node<E> current = head;
    for(int i = 0; i < size; i++) {
      if(head.element == e) {
        return i;
      }
      current = current.next;        
    }
    return -1;
  }

  //返回从前往后查找符合条件的最后一个结点
  @Override
  public int lastIndexOf(E e) {
    Node<E> current = head;
    int temp = -1;
    for(int i = 0; i < size; i++) {
      if(current.element == e) {
        temp = i;
      }
      current = current.next;
    }
    return temp;
  }

  @Override
  public E get(int index) {
    Node<E> current = head;
    if(index < 0 || index > size -1) return null;
    for(int i = 0; i < index; i++) {
      current = current.next;
    }
    return current.element;
  }

  public E getFirst() {
    if(size == 0) {
      return null;
    }
    else {
      return head.element;
    }
  }

  public E getLast() {
    if(size == 0) {
      return null;
    }
    else {
      return tail.element;
    }
  }

  @Override
  public String toString() {
    StringBuilder result = new StringBuilder("[");
    Node<E> current = head;
    for(int i = 0; i < size; i++) {
      result.append(current.element);
      current = current.next;
      if(current != null) {
        result.append(",");
      }
      else {
        result.append("]");
      }
    }
    return result.toString();
  }

  @Override
  public boolean contains(E e) {
    Node<E> current = head;
    for(int i = 0; i < size; i++) {
      if(head.element == e) {
        return true;
      }
      current = current.next;        
    }
    return false;
  }

  @Override
  public Iterator<E> iterator() {
    return new MyLinkedListIterator();
  }

  private class MyLinkedListIterator implements Iterator<E>{
    private Node<E> current = head;

    @Override
    public boolean hasNext() {
      return (current != null);
    }

    @Override
    public E next() {
      E e = current.element;
      current = current.next;
      return e;
    } 

//    @Override
//    public E remove() {
//      
//    }
  }
}

5. 总结

数组线性表和链表在大部分情况下性能差不多，但同时他们也有各自的优势，应该根据不同的应用场景进行选择。

• 数组线性表在按索引查找时的时间复杂度1,而链表的时间复杂度为n。
• 数组在头节点和尾结点删除元素的时间复杂度为n，而链表的时间复杂度为1。