單向鏈表（單鏈表）的Java實現

　　最近被問到鏈表，是一個朋友和我討論Java的時候說的。說實話，我學習編程的近一年時間里，學到的東西還是挺少的。語言是學了Java和C#，關於Web的學了一點Html+css+javascript。因為比較偏好，學習WinForm時比較認真，數據庫操作也自己有所研究。但鏈表這個東西我還真沒有學習和研究過，加上最近自己在看WPF，而課程也到了JSP了，比較緊。

　　但是我還是抽了一個晚上加半天的時間看了一下單向鏈表。並且使用Java試着寫了一個實例出來。沒有接觸過鏈表的朋友可以作為參考，希望大家多提寶貴意見。

　　當然，我們首先解釋一下什么是鏈表。就我所知，鏈表是一種數據結構，和數組同級。比如，Java中我們使用的ArrayList，其實現原理是數組。而LinkedList的實現原理就是鏈表了。我的老師說，鏈表在進行循環遍歷時效率不高，但是插入和刪除時優勢明顯。那么他有着愈十年的編程經驗，我是相信的。不過不知道他是否是說雙向鏈表，我們在此呢只對單向鏈表做一個了解。

　　鏈表（Chain本文所說鏈表均為單向鏈表，以下均簡稱單向鏈表）實際上是由節點（Node）組成的，一個鏈表擁有不定數量的節點。而向外暴露的只有一個頭節點（Head），我們對鏈表的所有操作，都是直接或者間接地通過其頭節點來進行的。

　　節點（Node）是由一個需要儲存的對象及對下一個節點的引用組成的。也就是說，節點擁有兩個成員：儲存的對象、對下一個節點的引用。

　　這樣說可能大家不是很明白，我貼一張圖大家可能更容易理解。

　　

　　那么大家可能清除了，為什么說有了頭節點就可以操作所有節點。因為有着不斷的引用嘛！

　　那么在鏈表里的屬性大概就只有兩個了：頭節點和節點數量。當然，根據需要，我們通常需要更多的屬性。

　　簡單的鏈表可以寫為下面的樣子：

package myChain;

/**
 * （單向）鏈表
 * 
 * @author Johness
 */
public class PersonChain {
    private PersonChainNode head; // 頭節點
    private int size; // 鏈表的實體（即節點的數量）
    private int modCount; // 鏈表被操作的次數（備用）

    /**
     * 獲得鏈表中節點數量
     * 
     * @return 鏈表中節點數
     */
    public int getSize() {
        return this.size;
    }

    /**
     * 添加節點的一般方法
     * 
     * @param p
     *            添加到鏈表節點的對象 由於實現細節，作為唯一標識，同一個編號的Person只能添加一次
     */
    public void addNode(Person p) {
        if (!contains(p.personNo)) { // 如果鏈表中沒有該對象，則准備添加
            if (head != null) { // 如果有頭節點，則添加新節點作為頭節點
                head = new PersonChainNode((myChain.Person) p, head);
                size++;
                modCount++;
            } else { // 如果沒有頭節點，則添加對象作為頭節點
                head = new PersonChainNode((myChain.Person) p, null);
                size++;
                modCount++;
            }
        }
    }
}

　　以上的代碼就是一般鏈表的骨架了。擁有兩個重要屬性。

　　那么做為能添加到鏈表的節點又該長什么樣子呢？

　　我們可以寫作如下：

package myChain;

/**
 * （節點）實體，封裝了'人'這個對象和下一個實體的引用
 * 該實體將作為（單向）鏈表的節點
 * @author Johness
 */
public class PersonChainNode {
    Person person;                            // 人
    PersonChainNode nextNode;        // 該對象（'人'）保存的下一個對象的引用
    
    // 獲取當前實體對象（'人'）
    public Person getPerson(){
        return this.person;
    }
    
    // 獲取下一個實體
    public PersonChainNode getNextNode(){
        return this.nextNode;
    }
    
    // 構造方法
    public PersonChainNode (Person p,PersonChainNode ep){
        this.person = p;
        this.nextNode = ep;
    }
}

　　當然了，這只是個大概的樣子。

　　那么我最后在把層次梳理一下：鏈表是由不定數量的節點連接（通過相互之間的引用）起來的，由於這種關系，在鏈表里我們只定義了頭節點和節點數量。節點是由存儲的對象及對下一個“節點”的引用封裝而成。

　　在添加節點到鏈表中時，首先添加的節點后置后，新添加的節點作為頭節點引用前一個添加的節點。

　　廢話不多說，貼上我的例子，老師說我廢話多……

　　（以下的例子較為簡陋，大家不要笑話我哈）

package myChain;

/**
 * '人' 類
 * @author Johness
 * @version 1.0
 */
public class Person {
    String name;        // 姓名
    int age;                // 年齡
    int personNo;     // 編號，用作唯一標識
    
    // 帶參構造方法
    public Person(String name, int age, int personNo) {
        this.name = name;
        this.age = age;
        this.personNo = personNo;
    }

    // 獲取姓名
    public String getName(){
        return this.name;
    }
    
    // 獲取年齡
    public int getAge(){
        return this.age;
    }
    
    // 獲取編號
    public int getPersonNo(){
        return this.personNo;
    }
    
    // 用於輸出的信息
    public String toString(){
        return "姓名：" + this.name + "\t年齡：" + this.age +"\t編號" + this.personNo;
    }
}

　　

package myChain;

/**
 * （節點）實體，封裝了'人'這個對象和下一個實體的引用
 * 該實體將作為（單向）鏈表的節點
 * @author Johness
 */
public class PersonChainNode {
    Person person;                            // 人
    PersonChainNode nextNode;        // 該對象（'人'）保存的下一個對象的引用
    
    // 獲取當前實體對象（'人'）
    public Person getPerson(){
        return this.person;
    }
    
    // 獲取下一個實體
    public PersonChainNode getNextEntity(){
        return this.nextNode;
    }
    
    // 構造方法
    public PersonChainNode (Person p,PersonChainNode ep){
        this.person = p;
        this.nextNode = ep;
    }
    
    // 構造方法
    public PersonChainNode (Person p){
        this.person = p;
    }
}

package myChain;

/**
 * （單向）鏈表
 * 
 * @author Johness
 */
public class PersonChain {
    private PersonChainNode head; // 頭節點
    private int size; // 鏈表的實體（即節點的數量）
    private int modCount; // 鏈表被操作的次數（備用）

    /**
     * 獲得鏈表中節點數量
     * 
     * @return 鏈表中節點數
     */
    public int getSize() {
        return this.size;
    }

    /**
     * 添加節點的一般方法
     * 
     * @param p
     *            添加到鏈表節點的對象 由於實現細節，作為唯一標識，同一個編號的Person只能添加一次
     */
    public void addNode(Person p) {
        if (!contains(p.personNo)) { // 如果鏈表中沒有該對象，則准備添加
            if (head != null) { // 如果有頭節點，則添加新節點作為頭節點
                head = new PersonChainNode((myChain.Person) p, head);
                size++;
                modCount++;
            } else { // 如果沒有頭節點，則添加對象作為頭節點
                head = new PersonChainNode((myChain.Person) p, null);
                size++;
                modCount++;
            }
        }
    }

    /**
     * 通過編號刪除對象
     * 
     * @param personNo
     *            要刪除對象的編號
     */
    public void deleteNode(int personNo) {
        if (size == 0) { // 如果當前鏈表節點數為零
            return;
        }
        if (size == 1) { 
            // 如果只有一個節點並且正是需要刪除的對象
            if (head.person.personNo == personNo) {
                head = null;
                size = 0;
            }
            return;
        }
        // 如果不存在該對象編號
        if (!contains(personNo)) {
            return;
        }

        // 較為復雜的刪除，定義整型保存被刪除的節點的索引
        //（刪除和索引都是不存在的，這里只是一個說法）
        int index = 0;
        // 循環遍歷，找到刪除節點的索引
        for (PersonChainNode p = head; p != null; p = p.nextNode) {
            if (!(p.person.personNo == personNo)) {
                index++;
            } else {
                break;
            }
        }
        // 如果刪除的是第一個節點（即頭節點）
        if (index == 0) {
            head = new PersonChainNode(head.nextNode.person,
                    head.nextNode.nextNode);    // 設置頭節點后一個節點為新的頭節點
            size--;                                            // 鏈表節點數減一
            modCount++;                                // 鏈表被操作次數加一
            return;
        }
        
        // 如果刪除的節點不是第一個節點
        // 循環遍歷，找到被刪除節點的前一個節點
        // 其索引下標用count保存
        int count = 0;
        for (PersonChainNode p = head; p != null; p = p.nextNode) {
            if (count == index - 1) {    // 如果找到了被刪除節點的前一個節點
                if (index == size - 1) {    // 如果被刪除節點是最后一個節點
                    p.nextNode = null;    // 將被刪除節點的前一個節點的引用指向空引用
                } else {                            // 如果被刪除節點不是最后一個節點
                    p.nextNode = p.nextNode.nextNode;    // 將被刪除節點前一個節點對其引用指向被刪除節點的下一個節點
                }
                size--;                // 減一數量
                modCount++;    // 加一操作次數
                return;
            }
            count++;                // 沒有找到，索引加一
        }
    }

    /**
     * 通過姓名查找對象
     * 未實現
     * @param name
     *            對象姓名
     * @return 對象數組，可能多個
     */
    public Person[] searchNodeByPersonName(String name) {
        return null;
    }

    /**
     * 通過年齡查找對象
     * 未實現
     * @param age
     *            對象年齡
     * @return 對象數組，可能多個
     */
    public Person[] searchPersonByAge(int age) {
        return null;
    }

    /**
     * 通過編號查找對象
     * 由於編號是唯一標識，循環遍歷查找並返回即可
     * @param personNo
     *            對象編號
     * @return 查找到的對象或者null
     */
    public Person searchNode(int personNo) {
        Person p = null;
        for (PersonChainNode pcn = head; pcn != null; pcn = pcn.nextNode) {
            if (pcn.person.personNo == personNo) {
                p = pcn.person;
            }
        }
        return p;
    }

    /**
     * 通過原對象修改及傳入值修改該對象屬性
     * 
     * @param personNo
     *            要修改的對象編號
     * @param value
     *            通過傳入值的類型判斷修改 只能修改姓名或年齡
     */
    public void editNode(int personNo, Object value) {
        // 通過作為唯一標識的編號查找到對象
        Person target = searchNode(personNo);
        if (target == null) {    // 如果對象為null
            return;
        }
        if (value == null) {    // 如果傳入參數為null
            return;
        }
        // 如果傳入參數為字符串類型
        if (value.getClass() == java.lang.String.class) {
            target.name = value.toString();
            return;
        }
        try {
            // 如果傳入參數為整型
            target.age = Integer.parseInt(value.toString());
            return;
        } catch (Exception ex) {
            // 如果傳入參數類型錯誤
            return;
        }
    }

    /**
     * 通過對象編號打印對象
     * 
     * @param personNo
     *            對象編號
     */
    public void printNode(int personNo) {
        Person target = searchNode(personNo);
        if (target == null) {
            return;
        }
        System.out.println(target.toString());
    }

    /**
     * 判斷指定對象是否存在鏈表中
     * 
     * @param personNo
     *            對象編號
     * @return true表示存在該對象，false表示不存在該對象
     */
    public boolean contains(int personNo) {
        if (size != 0) {
            for (PersonChainNode pcn = head; pcn != null; pcn = pcn.nextNode) {
                if (pcn.person.personNo == personNo) {
                    return true;
                }
            }
        }
        return false;
    }

    // 排序方法

    /**
     * 通過姓名排序
     */
    public void sortByPersonName() {
    }

    /**
     * 通過年齡排序
     */
    public void sortByPersonAge() {
    }

    /**
     * 默認排序，通過編號排序 
     * 使用冒泡排序，增加了判斷以提高效率
     */
    public void sort() {
        boolean jx = true;        // 冒泡排序的簡化方法
        for (PersonChainNode pcn = head; pcn != null && jx; pcn = pcn.nextNode) {
            jx = false;
            for (PersonChainNode pc = head; pc != null && pc.nextNode != null; pc = pc.nextNode) {
                if (pc.person.personNo > pc.nextNode.person.personNo) {
                    Person temp = pc.person;
                    pc.person = pc.nextNode.person;
                    pc.nextNode.person = temp;
                    jx = true;
                }
            }
        }
    }

    /**
     * 打印整個鏈表
     */
    public void printAll() {
        if (size != 0) {
            for (PersonChainNode pcn = head; pcn != null; pcn = pcn.nextNode) {
                System.out.println(pcn.person.toString());
            }
        }
    }
}

　　2012-04-11 21:33:32

　　那么實際上呢，我們在Java編程中使用的LinkedList就是在其內部維護着一個鏈表。

　　實際上的操作不外乎增刪改查，不同的是由於高度封裝，Jdk的LinkedList是使用索引來取得對象並進行操作的。

　　和以上我的例子是不盡相同的，因為我是安全按照自己的需求來做的，這樣比較簡單，實際上為了代碼重用復用和擴展。Jdk內的鏈表節點不知道保存的信息，因此沒有辦法以除了索引之外的方式獲取元素。

　　

　　今天課程到了Java集合框架，老師略微提了一下單向不循環鏈表。

　　我將老師的舉例改編一下，幫助大家理解：

　　老師需要找某一個同學，但是碰巧實在放假的時間內。同學們所處的位置都不一樣。老師知道班長的手機號碼，所以老師打電話給了班長，班長說他也不知道，但是他知道'我'的電話，他又打給我，我也不知道那位同學的地址，我又繼續向下一個同學打電話，直到找到他。

　　那么在以上示例中，加入每一個同學都有另一個同學的電話（有且僅有一個）。

　　我們就可以說符合單向鏈表的環境了。大家可以理解記憶。

 

　　大家都知道，我們所創建的對象是保存在內存中的。數組是如此，鏈表也是如此。

　　但是數組是一個整體空間，所有元素共用。就比如教室內上課的同學們。教室的容量是固定的，同學可少不可多，老師若希望進行查詢，能夠一眼看出來。

　　鏈表和其節點是不同的存儲位置，比如我們一個班畢業了。有的同學去了國外，有的去了北京。大家的位置不同，但是有一定聯系的。

 

　　2012-04-23 19:16:20