Java数据结构和算法系列1--链表

在Java编程道路上已经行走了6年多了，平时在工作当中，一般都是应用层面的开发，涉及到底层的不多，就算有些逻辑算法要写，也可以找到现成的框架来完成，这里不得不自吹自擂下Java的好处了，因为Java开源框架太多了，而且非常成熟丰富。 对于Java数据结构和算法可能有些模糊了，那么现在就此做些整理。
今天就来介绍下链表的数据结构，实现一个简单的单向链表。

1 链表数据结构

链表数据结构如下图：

链表包含一个头节点header和很多个Node节点，每个Node节点有数据和指向下一个节点next属性。next指向下一个Node节点。

2 具体实现

我们来用Java代码实现链表的添加，删除，遍历，打印，2个有序链表的合并功能。

//SimpleLinkNode.java
/**
 * 
 * 简单单项链表-节点
 * 
 * @author tngtech
 * 
 * <p>博客:http://blog.youkuaiyun.com/jacman
 * 
 * <p>https://github.com/tangthis
 */
public class SimpleLinkNode {
    int element;
    SimpleLinkNode next;


    public SimpleLinkNode() {
        super();
    }

    public SimpleLinkNode(int element){
        this.element = element;
    }

    public SimpleLinkNode(int element, SimpleLinkNode next) {
        super();
        this.element = element;
        this.next = next;
    }
    public int getElement() {
        return element;
    }
    public void setElement(int element) {
        this.element = element;
    }
    public SimpleLinkNode getNext() {
        return next;
    }
    public void setNext(SimpleLinkNode next) {
        this.next = next;
    }


}

//SimpleLinkList.java
/**
 * 
 * 简单单向链表
 * 
 * @author tngtech
 * 
 *         <p>
 *         博客:http://blog.youkuaiyun.com/jacman
 * 
 *         <p>
 *         Github:https://github.com/tangthis
 */
public class SimpleLinkList {

    /** 头节点 */
    private SimpleLinkNode header = null;

    /** 尾节点 */
    private SimpleLinkNode tail = null;

    /**
     * 初始化一个链表（设置头节点head）
     * 
     * @param node
     */
    public void initList(SimpleLinkNode node) {
        this.header = node;
        this.header.next = tail;
    }

    /**
     * 添加节点
     * 
     * @param node
     */
    public void addToList(SimpleLinkNode node) {
        if (header == null) {
            initList(node);
        } else {
            SimpleLinkNode temp = header;
            header = node;
            header.next = temp;
        }
    }

    /**
     * 遍历打印节点
     * 
     * @param myList
     */
    public static void printList(SimpleLinkList myList) {
        SimpleLinkNode tmp = null;
        for (tmp = myList.getHeader(); tmp != null; tmp = tmp.next) {
            System.out.print(tmp.getElement() + " ");
        }
        System.out.println();
    }

    /**
     * 打印单链表
     * 
     * @param head
     *            链表头指针
     */
    public static void printLinkNode(SimpleLinkNode head) {
        if (head == null || head.next == null) {
            return;
        }
        System.out.print(head.getElement() + " ");
        head = head.next;
        while (head != null) {
            System.out.print(head.element + " ");
            head = head.next;
        }
        System.out.println();
    }

    /**
     * 删除链表中的节点
     * 
     * @param node
     * @param myList
     */
    public void deleteNode(SimpleLinkNode node, SimpleLinkList myList) {
        if (myList == null) {
            return;
        }

        // 判断是否头节点并且删除
        if (myList.header != null && myList.header.getElement() == node.getElement()) {
            header = header.next;
            return;
        }

        SimpleLinkNode tmp;
        for (tmp = myList.getHeader(); tmp != null; tmp = tmp.next) {
            if (tmp.next != null && node.getElement() == tmp.next.getElement()) {// 该元素和下一个元素相同，指针指向下一个元素的下一个元素
                if (tmp.next.next != null) {
                    tmp.next = tmp.next.next;
                } else {
                    tmp.next = null;
                }
                break;// 跳出循环
            }
        }

    }

    public SimpleLinkNode getHeader() {
        return header;
    }

    public void setHeader(SimpleLinkNode header) {
        this.header = header;
    }

    public SimpleLinkNode getTail() {
        return tail;
    }

    public void setTail(SimpleLinkNode tail) {
        this.tail = tail;
    }

    /**
     * 合并2个有序链表
     * @param a 有序链表1
     * @param b 有序链表2
     * @param union 合并后的链表
     * @return
     */
    public static SimpleLinkNode union(SimpleLinkNode a, SimpleLinkNode b, SimpleLinkNode union) {
        SimpleLinkNode pc = union = a;
        SimpleLinkNode pa = a.next;
        SimpleLinkNode pb = b.next;

        while (pa != null && pb != null) {
            if (pa.element < pb.element) {
                pc.next = pa;
                pc = pa;
                pa = pa.next;
            } else {
                pc.next = pb;
                pc = pb;
                pb = pb.next;
            }
            pc.next = pb;
        }
        return union;
    }

    public static void main(String[] args) {
        //生成2个链表
        SimpleLinkList pa = new SimpleLinkList();
        for (int i = 1; i <= 10; i++) {
            SimpleLinkNode node = new SimpleLinkNode(i);
            pa.addToList(node);
        }
        System.out.println("链表pa:");
        printList(pa);
        SimpleLinkList pb = new SimpleLinkList();
        for (int i = 20; i <= 30; i++) {
            SimpleLinkNode node = new SimpleLinkNode(i);
            pb.addToList(node);
        }
        System.out.println("链表pb:");
        printList(pb);
        SimpleLinkNode union = null;
        union = union(pa.getHeader(), pb.getHeader(), union);
        System.out.println("合并后union:");
        printLinkNode(union);
    }

}

和数组相比，链表的优势在于长度不受限制，并且在进行插入和删除操作时，不需要移动数据项，效率上还是比数组要高很多
劣势在于随机访问，无法像数组那样直接通过下标找到特定的数据项

	链表	数组
插入	快	慢
删除	快	慢
查找	慢	快

Github源码：https://github.com/tangthis/java-data