java线性表学习笔记（二）

链表中的每一个元素都包含一个称为节点的结构，每向链表中增加一个元素，就会产生一个与之相关的节点，每个节点与它相邻的节点相连接（这是基础吧，不过在看c的时候没认真看，呼）。

定义节点类如下(使用了泛型，下面有个简单的具体实例)：

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

下面讲解一个储存3个元素的链表的例子，每一个节点储存一个字符串；

1、先声明head(指向第一个节点) 和tai(指向最后一个节点)，刚开始时都是null

Node<E> head  =  null;
Node<E> tail   =  null;
//链表为空

2、追加第一个节点

head = new Node<E>("Chicgo")；
last = head;

3、追加第二个节点

tail.next  = new Node<E>("Denver");
tail = tail.next;

3、追加第三个节点

tail.next = new Node<E>("Dallas");
tail = tail.next;

每一个节点都包含元素和一个名为next的数据域，next指向下一个元素。如果元素是链表中的最后一个元素。则它的next所包含的为null，用这个特性可以检测某个节点是否为最后一个节点，例如下面的遍历程序：

Node current  = head;
while()current !＝null){
    System.out.println(current.element);
    current = current.next;
}

下面就结合上面的知识给个简单的int类型事例：

//一个节点类，每一个元素都包含了一个称为节点的结构
public class Node{  
    int element;
    Node next ;
     public Node(int n){  //元素赋值
         element = n;
     }    
    public static void main(String[] args) {
        Node head , tail;             //申明head和tail
        head = new Node(1);          //插入第一个元素        
        tail = head;                 //head和tail在一起
        System.out.println(head.element);     //输出第一个元素
        tail.next = new Node(2);       //插入第二个元素
        tail = tail.next;
        tail.next =new Node(3);
        tail = tail.next;
        Node current = head ;
        while (current != null){     //遍历寻遍输出
            System.out.print(current.element);
            current = current.next;    
        }
    }
}

java中有提供LinkedList的类，可以通过导入 java.util.LinkedList来使用，不过书本上有教我们写一个自己的MyLinkedList，便于理解，这对我们掌握链表还是很有必要的。下面我们可以来仔细研究一下MyLinkedList了，有好多方法，不像MyArrayList容易理解，书本上也只是讲了几个方法，剩下的就自己去理解了，也不是很难，这里讲3个吧，就当练习打字。

（补充：head始终指向链表的第一个节点，而tail则始终指向最后一个节点）

1、实现addFirst(e)方法，就是创建第一个节点：

//创建一个包含e元素节点，并放在第一个节点
  public void addFirst(E e) {
    Node<E> newNode = new Node<E>(e); // 创建一个的节点
    newNode.next = head; //新节点的next数据域指向head
    head = newNode; // head 指向新的节点
    size++; 

    if (tail == null) // 若链表为空，则head和tail都指向新节点
      tail = head;
  }

（书本上的那个图很好看，但是画不下来==）

2、实现add(index,e)方法，当index为0或则是在最后一个元素时就不说了，直接调用方法addFirst(e)或则addLast(e)就行了，若插入到中间时，假设为current和temp节点之间，则首先从head开始前进找到current的next，并被新节点赋给它，在把新节点的next指向temp，画个图就很容易理解了。

public void add(int index, E e) {
    if (index == 0) {
      addFirst(e);
    }
    else if (index >= size) {
      addLast(e);
    }
    else {
      Node<E> current = head;
      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++;
    }
  }

3、实现removeLast()方法，如果链表为空就返回null，如果只有一个节点就销毁并且head和tail都变为null,否则最后一个节点销毁，tail指向倒数第二个节点，size减一。

public E removeLast() {
   if (size == 0) {
     return null;
   }
   else if (size == 1) {
     Node<E> temp = head;
     head = tail = null;
     size = 0;
     return temp.element;
   }
   else {
     Node<E> current = head;    //要从head开始遍历，增加了时间
     for (int i = 0; i < size - 2; i++) {
       current = current.next;  //找到倒数第二个节点
     }

     Node<E> temp = tail;    //临时引用temp
     tail = current;
     tail.next = null;
     size--;
     return temp.element;     
   }
 }

最后在给出MyLinkedList的实现(仅有部分方法实现，还有部分，做作业)：

public class MyLinkedList<E> extends MyAbstractList<E> {
  private Node<E> head, tail;

  //创建默认链表
  public MyLinkedList() {
  }

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

  //获得链表的头
  public E getFirst() {
    if (size == 0) {
      return null;
    }
    else {
      return head.element;
    }
  }

  //获得链表的尾
  public E getLast() {
    if (size == 0) {
      return null;
    }
    else {
      return tail.element;
    }
  }

  //创建一个包含e元素节点，并放在第一个节点
  public void addFirst(E e) {
    Node<E> newNode = new Node<E>(e); // 创建一个的节点
    newNode.next = head; //新节点的next数据域指向head
    head = newNode; // head 指向新的节点
    size++; 

    if (tail == null) // 若链表为空，则head和tail都指向新节点
      tail = head;
  }

  //创建一个包含e元素节点，并放在最后一个节点
  public void addLast(E e) {
    Node<E> newNode = new Node<E>(e); 

    if (tail == null) {
      head = tail = newNode; 
    }
    else {
      tail.next = newNode; 
      tail = tail.next;
    }
    size++; 
  }


  //将一个元素插入到链表的指定下标处
  public void add(int index, E e) {
    if (index == 0) {
      addFirst(e);
    }
    else if (index >= size) {
      addLast(e);
    }
    else {
      Node<E> current = head;
      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 E removeFirst() {
    if (size == 0) {
      return null;
    }
    else {
      Node<E> temp = head;
      head = head.next;
      size--;
      if (head == null) {
        tail = null;
      }
      return temp.element;
    }
  }

  //删除最后一个元素
  public E removeLast() {
    if (size == 0) {
      return null;
    }
    else if (size == 1) {
      Node<E> temp = head;
      head = tail = null;
      size = 0;
      return temp.element;
    }
    else {
      Node<E> current = head;    //要从head开始遍历，增加了时间
      for (int i = 0; i < size - 2; i++) {
        current = current.next;  //找到倒数第二个节点
      }

      Node<E> temp = tail;    //临时引用temp
      tail = current;
      tail.next = null;
      size--;
      return temp.element;     
    }
  }

  //删除指定下标的元素
  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;

      for (int i = 1; i < index; i++) {
        previous = previous.next;
      }

      Node<E> current = previous.next;
      previous.next = current.next;
      size--;
      return current.element;
    }
  }

  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();
  }

  //清空
  public void clear() {
    head = tail = null;
  }

  
  /** Return true if this list contains the element o */
  public boolean contains(E o) {
    System.out.println("Implementation left as an exercise");
    return true;
  }

  /** Return the element from this list at the specified index */
  public E get(int index) {
    System.out.println("Implementation left as an exercise");
    return null;
  }

  /** Return the index of the head matching element in this list.
   *  Return -1 if no match. */
  public int indexOf(E o) {
    System.out.println("Implementation left as an exercise");
    return 0;
  }

  /** Return the index of the last matching element in this list
   *  Return -1 if no match. */
  public int lastIndexOf(E o) {
    System.out.println("Implementation left as an exercise");
    return 0;
  }

  /** Replace the element at the specified position in this list
   *  with the specified element. */
  public Object set(int index, E o) {
    System.out.println("Implementation left as an exercise");
    return null;
  }


  private static class Node<E> {
    E element;
    Node<E> next;

    public Node(E element) {
      this.element = element;
    }
  }
}

在附上一个测试程序：

public class TestLinkedList {
  /** Main method */
  public static void main(String[] args) {
    // Create a list for strings
    MyLinkedList<String> list = new MyLinkedList<String>();

    // Add elements to the list
    list.add("America"); // Add it to the list
    System.out.println("(1) " + list);

    list.add(0, "Canada"); // Add it to the beginning of the list
    System.out.println("(2) " + list);

    list.add("Russia"); // Add it to the end of the list
    System.out.println("(3) " + list);

    list.addLast("France"); // Add it to the end of the list
    System.out.println("(4) " + list);

    list.add(2, "Germany"); // Add it to the list at index 2
    System.out.println("(5) " + list);

    list.add(5, "Norway"); // Add it to the list at index 5
    System.out.println("(6) " + list);

    list.add(0, "Poland"); // Same as list.addFirst("Poland")
    System.out.println("(7) " + list);

    // Remove elements from the list
    list.remove(0); // Same as list.remove("Australia") in this case
    System.out.println("(8) " + list);

    list.remove(2); // Remove the element at index 2
    System.out.println("(9) " + list);

    list.remove(list.size() - 1); // Remove the last element
    System.out.println("(10) " + list);
  }
}

关于MyArrayList和MyLinkedList的方法的复杂度，看下面的图