java 数据结构部分

List：
所有已知实现类：
AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector；
来说一下stack和vector，

stack：
先看下api里的方法摘要
boolean empty()
测试堆栈是否为空。
E peek()
查看堆栈顶部的对象，但不从堆栈中移除它。
E pop()
移除堆栈顶部的对象，并作为此函数的值返回该对象。
E push(E item)
把项压入堆栈顶部。
int search(Object o)
返回对象在堆栈中的位置，以 1 为基数。

再看个具体例子：
括号配对问题

描述
现在，有一行括号序列，请你检查这行括号是否配对。
输入
第一行输入一个数N（0<N<=100）,表示有N组测试数据。后面的N行输入多组输入数据，每组输入数据都是一个字符串S(S的长度小于10000，且S不是空串），测试数据组数少于5组。数据保证S中只含有"[","]","(",")"四种字符
输出
每组输入数据的输出占一行，如果该字符串中所含的括号是配对的，则输出Yes,如果不配对则输出No
样例输入
3
[(])
(])
([[]()])
样例输出
No
No
Yes
import java.util.Scanner;
import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int N = scan.nextInt();
        String s;
        for (int i = 0; i < N; i++) {
            s = scan.next();
            if (isMatch(s)) {
                System.out.println("Yes");
            } else {
                System.out.println("No");
            }
        }
    }
    private static boolean isMatch(String s) {
        Stack<Character> sk = new Stack<Character>();
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                sk.push('(');
            }
            if (s.charAt(i) == ')') {
                if (!sk.isEmpty() && sk.pop() == '(')
                    continue;
                else
                    return false;
            }
            if (s.charAt(i) == '[') {
                sk.push('[');
            }
            if (s.charAt(i) == ']') {
                if (!sk.isEmpty() && sk.pop() == '[')
                    continue;
                else
                    return false;
            }
        }
        if (sk.isEmpty())
            return true;
        else
            return false;
    }
}        

Vector：
rrayList会比Vector快，他是非同步的，如果设计涉及到多线程，还是用Vector比较好一些
Vector其实就是长度可以自己变化的ArrayList；

Queue接口：
具体实现只介绍LinkedList类
特点：从队列尾插入，队列头删除；

看几个主要的方法：
boolean add(E e)
将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回 true，如果当前没有可用的空间，则抛出 IllegalStateException。
E element()
获取，但是不移除此队列的头。
boolean offer(E e)
将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，此方法通常要优于 add(E)，后者可能无法插入元素，而只是抛出一个异常。
E peek()
获取但不移除此队列的头；如果此队列为空，则返回 null。
E poll()
获取并移除此队列的头，如果此队列为空，则返回 null。
E remove()
获取并移除此队列的头

实现类有LinkedList等；
简单的创建： Queue queue=new LinkedList（）；

LinkedList（链表）：
节点的定义：

class Node{
  Object element；
  Node next；
  public Node（Object o）{
    element = o;
    }
}

看个让单链表反向的例子：（取自网络）

class Node {
    char value;
    Node next;
}
public Node reverse(Node current) {
    //initialization
    Node previousNode = null;
    Node nextNode = null;

    while (current != null) {
        //save the next node
        nextNode = current.next;
        //update the value of "next"
        current.next = previousNode;
        //shift the pointers
        previousNode = current;
        current = nextNode;         
    }
    return previousNode;
}
第二种：用递归的方法
public Node reverse(Node current)
 {
     if (current == null || current.next == null) return current;
     Node nextNode = current.next;
     current.next = null;
     Node reverseRest = reverse(nextNode);
     nextNode.next = current;
     return reverseRest;
 }

递归的方法其实是非常巧的，它利用递归走到链表的末端，然后再更新每一个node的next 值 (代码倒数第二句)。 在上面的代码中， reverseRest 的值没有改变，为该链表的最后一个node，所以，反转后，我们可以得到新链表的head。