线性表（linear_list）

线性表 linear_list

定义

一个线性表是N个数据元素的有序序列。一个数据元素可以是若干个数据项组成的。数据元素可以称为记录。大量的记录称为文件。

线性结构的特点

数据元素的非空有限集合中，

1. 存在唯一的一个被称为“第一个”的数据元素;
2. 存在唯一的一个被称为“最后一个”的数据元素；
3. 除了第一个之外，集合中的每个数据元素均只有一个前驱；
4. 除了最后一个之外，集合中的每个数据元素均只有一个后驱。

线性表的表示

顺序表示

指的是用一组地址连续的存储单元依次存储线性表的数据元素。逻辑上相邻的地址，物理上一定相邻。

线性表的第一个数据元素的存储位置，称为起始位置或者基地址。只要确定起始位置，线性表中任一数据元素都是随机存取的，所以，线性表的顺序存储结构是一种随机存取的存储结构。

顺序表的三要素：空间首地址；空间大小；元素个数（当时的存放量）。

由于插入和删除数据元素会导致顺序表中的数据元素的移动，所以顺序表有着数据元素变动特别耗时的缺点。

链式表示

指的是用一组任意的存储单元存储线性表的数据元素。逻辑上相邻的地址，物理上不一定相邻。

它的每个数据元素中，有数据部分和指正部分，存放数据元素信息的部分称为数据域，存放后继位置信息的部分称为指针域。指针中存储的信息称为指针或者链，这样的一个数据元素称为节点（Node），多个节点链成一个链表。

链表的第一个节点称为头结点。

在链表进行插入和删除元素的时候，不需要移动数据元素，只需要修改节点中的指针就可以了。

单链表

单向链表（单链表）的链接方向是单向的，访问要从头部开始顺序读取。

一个单向链表的节点分为两个部分，1是数据区，用来保存数据，2是指针区，用来存储下一个节点的地址。，最后一个节点的指针是null。

package linkedList;

/**
 * 单链表
 */
public class SingleLinkedList {
    /**
     * 节点的个数
     */
    private int length;
    /**
     * 头节点
     */
    private Node head;

    public SingleLinkedList() {
        length = 0;
        head = null;
    }

    private class Node {
        private Object data;
        private Node next;

        public Node(Object data) {
            this.data = data;
        }
    }

    public Object addHead(Object object) {
        Node newNode = new Node(object);
        if (length == 0) {
            head = newNode;
        } else {
            head = newNode;
            newNode.next = head;
        }
        length++;
        return object;
    }

    public boolean delete(Object value) {
        if (length == 0) {
            return false;
        }
        Node current = head;
        Node previous = head;
        while (current.data != value) {
            if (current.next == null) {
                return false;
            } else {
                previous = current;
                current = current.next;
            }
        }

        if (current == head) {
            head = current.next;
            length--;
        } else {
            previous.next = current.next;
            length--;
        }
        return true;
    }

    public Node find(Object object) {
        Node current = head;
        int tempSize = length;
        while (tempSize > 0) {
            if (object.equals(current.data)) {
                return current;
            } else {
                current = current.next;
            }
            tempSize--;
        }
        return null;
    }
}

双向链表

双向链表的每个节点的指针域都有两个指针，分别指向其的直接后继和直接前驱节点。这样我们可以从两个方向访问和处理节点数据。

package linkedList;

/**
 * 双向链表
 */
public class TwoWayLinkedList {

    /**
     * 节点的个数
     */
    private int length;
    /**
     * 头节点
     */
    private Node head;
    /**
     * 尾节点
     */
    private Node tail;

    private class Node {
        private Object data;
        private Node next;
        private Node prev;

        public Node(Object data) {
            this.data = data;
        }
    }

    public TwoWayLinkedList() {
        length = 0;
        head = null;
        tail = null;
    }

    /**
     * 链表头部增加节点
     *
     * @param value
     */
    public void addHead(Object value) {
        Node newNode = new Node(value);
        if (length == 0) {
            head = newNode;
            tail = newNode;
            length++;
        } else {
            head.prev = newNode;
            newNode.next = head;
            head = newNode;
            length++;
        }
    }

    /**
     * 链表尾部增加节点
     *
     * @param value
     */
    public void addTail(Object value) {
        Node newNode = new Node(value);
        if (length == 0) {
            head = newNode;
            tail = newNode;
            length++;
        } else {
            newNode.next = tail;
            tail.next = newNode;
            tail = newNode;
            length++;
        }
    }

    /**
     * 删除头部节点
     *
     * @return
     */
    public Node deleteHead() {
        Node temp = head;
        if (length != 0) {
            head = head.next;
            head.prev = null;
            length--;
            return temp;
        } else {
            return null;
        }
    }

    /**
     * 删除尾部节点
     *
     * @return
     */
    public Node deleteTail() {
        Node temp = tail;
        if (length != 0) {
            tail = tail.prev;
            tail.next = null;
            length--;
            return temp;
        } else {
            return null;
        }
    }
}

循环链表

表中最后一个节点的指针域指向头结点，整个链表形成一个环。单向的。

静态链表

是使用一个数组表示链表，数据中的数据元素是个节点元素，节点元素中包含了数据成员和数组下标成员，通过存放下一个节点的数组下标来形成链。

链式表示与顺序表示对比

链式优缺点

存储空间的合理利用，只要是不一要物理上连续的存储单元。

插入、删除数据元素时不需要移动元素，速度快

不能进行随机存取，速度慢

顺序式优缺点

存储空间必须要和连续

插入、删除数据元素需要移动元素，速度慢

可以进行随机存储，查找速度快

---

参考

《数据结构 （C语言版）》 严蔚敏

《Java面试核心知识点》 王磊