①泡茶看数据结构-表ADT

前言

    小朽，晚上回到寝室。烧了开水，又泡了一杯下午喝了的小毛尖。耳机听着萨克斯，总结下今天学的数据结构和算法中的表ADT。

 

  　　　　  表ADT节点：

       　　　　　　 #单链表

      　　　　　　  #双链表

      　　　　　　  #循环链表

      　　　　　　  #浅谈面试题一道

 

                　　　　　　　　　　　　　　　　     

                喝一口热热的茶，算法和数据结构虽然枯燥，希望我不讲的枯燥。毛尖还是淡淡的味道，非常喜欢。

 

回顾

    ①ADT：带一组操作的一些对象的集合：对象及对象的操作。

    ②java考虑了ADT实现，隐藏了实现的细节。

 

单链表

    ①链表中的数据是以节点来表示的，每个节点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个节点的地址数据。

 

　　　　　　　　　　　　　　

 

　　上面是比较官方的，我的版本就像老式火车一样：火车节号→火车里面东西

 

　　　　　　　　　　　　　　

 

　　②思考

 

　　　　相比表的数组实现，单链表的好处明显的两点：避免了插入和删除的开销。还有值得说的一点，改变表的起始端（表头和亚节点）。以下是我的观点：如果像一些查询较多的应用，数组和链表都行。但像有些，更新和插入，删除多的情况，比如游戏中的装备等，就应该选择考虑下链表。这就是学这些的nice point。

 

　　　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　　　它冒着热气，像是生活，coding生活那样有味。

 　　③例子来一枚-java

package LinkedList;   
  
/**  
 * <p><strong>我的Java单链表练习</strong></p>  
 * <p>单链表提供了在列表头的高效插入和删除操作，不过在单链表的末尾的插入操作效率很低.</p>  
 * <p>单链表指针域保存着下一节点的引用，尾结点的指针域等于null</p>  
 * @author baby69yy2000  
 */  
public class SingleLinkedList<T> {   
       
    /**  
     * 结点类  
     */  
    private static class Node<T> {   
        T nodeValue; // 数据域   
        Node<T> next; // 指针域保存着下一节点的引用   
           
        Node(T nodeValue, Node<T> next) {   
            this.nodeValue = nodeValue;   
            this.next = next;   
        }   
           
        Node(T nodeValue) {   
            this(nodeValue, null);   
        }   
    }   
  
    // 下面是SingleLinkedList类的数据成员和方法   
    private Node<T> head, tail;   
       
    public SingleLinkedList() {   
        head = tail = null;   
    }   
       
    /**  
     * 判断链表是否为空  
     */  
    public boolean isEmpty() {   
        return head == null;   
    }   
       
    /**  
     * 创建头指针，该方法只用一次！  
     */  
    public void addToHead(T item) {   
        head = new Node<T>(item);   
        if(tail == null) tail = head;   
    }   
       
    /**  
     * 添加尾指针，该方法使用多次  
     */  
    public void addToTail(T item) {   
        if (!isEmpty()) { // 若链表非空那么将尾指针的next初使化为一个新的元素   
            tail.next = new Node<T>(item); // 然后将尾指针指向现在它自己的下一个元素   
            tail = tail.next;   
        } else { // 如果为空则创建一个新的！并将头尾同时指向它   
            head = tail = new Node<T>(item);         
        }   
    }   
       
    /**  
     * 打印列表  
     */  
    public void printList() {   
        if (isEmpty()) {   
            System.out.println("null");   
        } else {   
            for(Node<T> p = head; p != null; p = p.next)   
                System.out.println(p.nodeValue);   
        }   
    }   
       
    /**  
     * 在表头插入结点，效率非常高  
     */  
    public void addFirst(T item) {   
        Node<T> newNode = new Node<T>(item);   
        newNode.next = head;   
        head = newNode;   
    }   
       
    /**  
     * 在表尾插入结点，效率很低  
     */  
    public void addLast(T item) {   
        Node<T> newNode = new Node<T>(item);   
        Node<T> p = head;   
        while (p.next != null) p = p.next;   
        p.next = newNode;   
        newNode.next = null;   
    }   
       
    /**  
     * 在表头删除结点，效率非常高  
     */  
    public void removeFirst() {   
        if (!isEmpty()) head = head.next;   
        else System.out.println("The list have been emptied!");   
    }   
       
    /**  
     * 在表尾删除结点，效率很低  
     */  
    public void removeLast() {   
        Node<T> prev = null, curr = head;   
        while(curr.next != null) {   
            prev = curr;   
            curr = curr.next;   
            if(curr.next == null) prev.next = null;   
        }   
    }   
       
    /**  
     * <p>插入一个新结点</p>  
     * <ul>插入操作可能有四种情况:  
     * <li>①表为空, 返回false</li>  
     * <li>②表非空,指定的数据不存在</li>  
     * <li>③指定的数据是表的第一个元素</li>  
     * <li>④指定的数据在表的中间</li></ul>  
     * @param appointedItem 指定的nodeValue  
     * @param item 要插入的结点  
     * @return 成功插入返回true;  
     */  
    public boolean insert(T appointedItem, T item) {   
        Node<T>  prev = head, curr = head.next, newNode;   
        newNode = new Node<T>(item);   
        if(!isEmpty()) {   
            while((curr != null) && (!appointedItem.equals(curr.nodeValue))) { //两个判断条件不能换   
                prev = curr;   
                curr = curr.next;   
            }   
            newNode.next = curr; //②③④   
            prev.next = newNode;   
            return true;    
        }   
        return false; //①   
    }   
       
    /**  
     * <p>移除此列表中首次出现的指定元素</p>  
     * <ul>删除操作可能出现的情况:  
     * <li>①prev为空，这意味着curr为head. head = curr.next; --> removeFirst();</li>  
     * <li>②匹配出现在列表中的某个中间位置，此时执行的操作是 --> prev.next = curr.next;,</li></ul>  
     * <p>在列表中定位某个结点需要两个引用:一个对前一结点(prev左)的引用以及一个对当前结点(curr右)的引用.</p>  
     * prev = curr;  
     * curr = curr.next;  
     */  
    public void remove(T item) {   
        Node<T> curr = head, prev = null;   
        boolean found = false;   
        while (curr != null && !found) {   
            if (item.equals(curr.nodeValue)) {   
                if(prev == null) removeFirst();   
                else prev.next = curr.next;   
                found = true;   
            } else {   
                prev = curr;   
                curr = curr.next;   
            }   
        }   
    }   
       
    /**  
     * 返回此列表中首次出现的指定元素的索引，如果列表中不包含此元素，则返回 -1.  
     */  
    public int indexOf(T item) {   
        int index = 0;   
        Node<T> p;   
        for(p = head; p != null; p = p.next) {   
            if(item.equals(p.nodeValue))   
                return index;   
            index++;   
                   
        }   
        return -1;   
    }   
       
    /**  
     * 如果此列表包含指定元素，则返回 true。  
     */  
     public boolean contains(T item) {   
         return indexOf(item) != -1;   
     }   
       
    public static void main(String[] args) {   
        SingleLinkedList<String> t = new SingleLinkedList<String>();   
        t.addToHead("A");   
        //t.addFirst("addFirst");   
        t.addToTail("B");   
        t.addToTail("C");   
        System.out.println(t.indexOf("C")); // 2   
        System.out.println(t.contains("A")); // true   
        //t.addLast("addLast");   
        //t.removeLast();   
        //t.insert("B", "insert");   
        //t.removeFirst();   
        //t.remove("B"); // A C   
        t.printList(); // A B C   
           
    }   
  
}  

 双链表　　

　　

　　　　①双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。

 

　　　　　　　　　　　　　　　　

 

　　　　就像火车也升级了，我们一般都用双链表。快捷

 

　　　　　　　　　　　　　　　

　　

　　　　②思考

　　　　　　　相对单链表，这貌似给我们社会进步意义一样。更容易让我们随心所欲。自然这条路走过了是艰难的。

 

循环链表

 

　　①循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。

 

　　　　　　　　　　　　　　

 

　　　　我认为像小孩子牵着手：童真的我

 

　　　　　　　　　　

 

　　②思考：像那个经典的约瑟夫问题（有兴趣看看）：

　　　　　　http://baike.baidu.com/link?url=5pqQYc7yv8qBpEbJK3nldHrVfc0rKoOknhm47VNZgi5cnK4uzvzCSCpLsraBtcwo

　　　　　　

　　　　　　喝到底了，来块奥利奥加点料。希望你们记住了我说的。

 

面试题-单链表　　

　　

　　　　快速已知长度的单链表中间节点？

　　　　

　　　　　　①顺序呗，一个一个走过去。然后知道length，然后知道中间了。大O（N）

　　　　　　②利用二倍，第a个，看看2a，若2a是空，则a为中间。大O（N/2）

　　　　

总结

　　

　　不难不难我记住了，喝杯茶继续体会体会。晚安！