数据结构与算法之数组、单链表和双链表介绍

概要
线性表是一种线性结构,它是具有相同类型的n(n≥0)个数据元素组成的有限序列。本章先介绍线性表的几个基本组成部分:数组、单向链表、双向链表以及Java语言的实现。
数组
数组有上界和下界,数组的元素在上下界内是连续的。
存储10,20,30,40,50的数组的示意图如下:
数组的特点是:数据是连续的;随机访问速度快。
数组中稍微复杂一点的是多维数组和动态数组。对于Java而言,Collection集合中提供了ArrayList和Vector。
单向链表
单向链表(单链表)是链表的一种,它由节点组成,每个节点都包含下一个节点的指针。
单链表的示意图如下:

表头为空,表头的后继节点是"节点10"(数据为10的节点),"节点10"的后继节点是"节点20"(数据为10的节点),...
单链表删除节点

在"节点10"与"节点20"之间添加"节点15"
添加之前:"节点10" 的后继节点为"节点20"。
添加之后:"节点10" 的后继节点为"节点15",而"节点15" 的后继节点为"节点20"。
单链表的特点是:节点的链接方向是单向的;相对于数组来说,单链表的的随机访问速度较慢,但是单链表删除/添加数据的效率很高。
双向链表
双向链表(双链表)是链表的一种。和单链表一样,双链表也是由节点组成,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。
双链表的示意图如下:

表头为空,表头的后继节点为"节点10"(数据为10的节点);"节点10"的后继节点是"节点20"(数据为10的节点),"节点20"的前继节点是"节点10";"节点20"的后继节点是"节点30","节点30"的前继节点是"节点20";...;末尾节点的后继节点是表头。
双链表删除节点

删除"节点30"
删除之前:"节点20"的后继节点为"节点30","节点30" 的前继节点为"节点20"。"节点30"的后继节点为"节点40","节点40" 的前继节点为"节点30"。
删除之后:"节点20"的后继节点为"节点40","节点40" 的前继节点为"节点20"。

双链表添加节点

在"节点10"与"节点20"之间添加"节点15"
添加之前:"节点10"的后继节点为"节点20","节点20" 的前继节点为"节点10"。
添加之后:"节点10"的后继节点为"节点15","节点15" 的前继节点为"节点10"。"节点15"的后继节点为"节点20","节点20" 的前继节点为"节点15"。
下面介绍java双链表的实现
实现代码
双链表类(DoubleLink.java)
[AppleScript] 纯文本查看 复制代码
?

/**

  • Java 实现的双向链表。
  • 注:java自带的集合包中有实现双向链表,路径是:java.util.LinkedList

*/
public class DoubleLink<T> {

// 表头
private DNode<T> mHead;
// 节点个数
private int mCount;

// 双向链表“节点”对应的结构体
private class DNode<T> {
    public DNode prev;
    public DNode next;
    public T value;

    public DNode(T value, DNode prev, DNode next) {
        this.value = value;
        this.prev = prev;
        this.next = next;
    }
}

// 构造函数
public DoubleLink() {
    // 创建“表头”。注意:表头没有存储数据!
    mHead = new DNode<T>(null, null, null);
    mHead.prev = mHead.next = mHead;
    // 初始化“节点个数”为0
    mCount = 0;
}

// 返回节点数目
public int size() {
    return mCount;
}

// 返回链表是否为空
public boolean isEmpty() {
    return mCount==0;
}

// 获取第index位置的节点
private DNode<T> getNode(int index) {
    if (index<0 || index>=mCount)
        throw new IndexOutOfBoundsException();

    // 正向查找
    if (index <= mCount/2) {
        DNode<T> node = mHead.next;
        for (int i=0; i<index; i++)
            node = node.next;

        return node;
    }

    // 反向查找
    DNode<T> rnode = mHead.prev;
    int rindex = mCount - index -1;
    for (int j=0; j<rindex; j++)
        rnode = rnode.prev;

    return rnode;
}

// 获取第index位置的节点的值
public T get(int index) {
    return getNode(index).value;
}

// 获取第1个节点的值
public T getFirst() {
    return getNode(0).value;
}

// 获取最后一个节点的值
public T getLast() {
    return getNode(mCount-1).value;
}

// 将节点插入到第index位置之前
public void insert(int index, T t) {
    if (index==0) {
        DNode<T> node = new DNode<T>(t, mHead, mHead.next);
        mHead.next.prev = node;
        mHead.next = node;
        mCount++;
        return ;
    }

    DNode<T> inode = getNode(index);
    DNode<T> tnode = new DNode<T>(t, inode.prev, inode);
    inode.prev.next = tnode;
    inode.next = tnode;
    mCount++;
    return ;
}

// 将节点插入第一个节点处。
public void insertFirst(T t) {
    insert(0, t);
}

// 将节点追加到链表的末尾
public void appendLast(T t) {
    DNode<T> node = new DNode<T>(t, mHead.prev, mHead);
    mHead.prev.next = node;
    mHead.prev = node;
    mCount++;
}

// 删除index位置的节点
public void del(int index) {
    DNode<T> inode = getNode(index);
    inode.prev.next = inode.next;
    inode.next.prev = inode.prev;
    inode = null;
    mCount--;
}

// 删除第一个节点
public void deleteFirst() {
    del(0);
}

// 删除最后一个节点
public void deleteLast() {
    del(mCount-1);
}

}
测试程序(DlinkTest.java)
[Java] 纯文本查看 复制代码
?

/*/font Java 实现的双向链表。

  • 注:java自带的集合包中有实现双向链表,路径是:java.util.LinkedList

*/

public class DlinkTest {

// 双向链表操作int数据
private static void int_test() {
    int[] iarr = {10, 20, 30, 40};

    System.out.println("\n----int_test----");
    // 创建双向链表
    DoubleLink<Integer> dlink = new DoubleLink<Integer>();

    dlink.insert(0, 20);    // 将 20 插入到第一个位置
    dlink.appendLast(10);    // 将 10 追加到链表末尾
    dlink.insertFirst(30);    // 将 30 插入到第一个位置

    // 双向链表是否为空
    System.out.printf("isEmpty()=%b\n", dlink.isEmpty());
    // 双向链表的大小
    System.out.printf("size()=%d\n", dlink.size());

    // 打印出全部的节点
    for (int i=0; i<dlink.size(); i++)
        System.out.println("dlink("+i+")="+ dlink.get(i));
}


private static void string_test() {
    String[] sarr = {"ten", "twenty", "thirty", "forty"};

    System.out.println("\n----string_test----");
    // 创建双向链表
    DoubleLink<String> dlink = new DoubleLink<String>();

    dlink.insert(0, sarr[1]);    // 将 sarr中第2个元素 插入到第一个位置
    dlink.appendLast(sarr[0]);    // 将 sarr中第1个元素 追加到链表末尾
    dlink.insertFirst(sarr[2]);    // 将 sarr中第3个元素 插入到第一个位置

    // 双向链表是否为空
    System.out.printf("isEmpty()=%b\n", dlink.isEmpty());
    // 双向链表的大小
    System.out.printf("size()=%d\n", dlink.size());

    // 打印出全部的节点
    for (int i=0; i<dlink.size(); i++)
        System.out.println("dlink("+i+")="+ dlink.get(i));
}


// 内部类
private static class Student {
    private int id;
    private String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "["+id+", "+name+"]";
    }
}

private static Student[] students = new Student[]{
    new Student(10, "sky"),
    new Student(20, "jody"),
    new Student(30, "vic"),
    new Student(40, "dan"),
};

private static void object_test() {
    System.out.println("\n----object_test----");
    // 创建双向链表
    DoubleLink<Student> dlink = new DoubleLink<Student>();

    dlink.insert(0, students[1]);    // 将 students中第2个元素 插入到第一个位置
    dlink.appendLast(students[0]);    // 将 students中第1个元素 追加到链表末尾
    dlink.insertFirst(students[2]);    // 将 students中第3个元素 插入到第一个位置

    // 双向链表是否为空
    System.out.printf("isEmpty()=%b\n", dlink.isEmpty());
    // 双向链表的大小
    System.out.printf("size()=%d\n", dlink.size());

    // 打印出全部的节点
    for (int i=0; i<dlink.size(); i++) {
        System.out.println("dlink("+i+")="+ dlink.get(i));
    }
}


public static void main(String[] args) {
    int_test();        // 演示向双向链表操作“int数据”。
    string_test();    // 演示向双向链表操作“字符串数据”。
    object_test();    // 演示向双向链表操作“对象”。
}

}

运行结果
[Java] 纯文本查看 复制代码
?

----int_test----
isEmpty()=false
size()=3
dlink(0)=30
dlink(1)=20
dlink(2)=10

----string_test----
isEmpty()=false
size()=3
dlink(0)=thirty
dlink(1)=twenty
dlink(2)=ten

----object_test----
isEmpty()=false
size()=3
dlink(0)=[30, vic]
dlink(1)=[20, jody]
dlink(2)=[10, sky]

评论

暂无评论