单向链表（单链表）的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