线性表(linear_list)

Posted 顧棟

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了线性表(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面试核心知识点》 王磊

以上是关于线性表(linear_list)的主要内容,如果未能解决你的问题,请参考以下文章

线性表(线性表的类型定义)

线性表(线性表的类型定义)

数据结构之顺序表

Android 底部工作表布局边距

如何通过单击片段内的线性布局从片段类开始新活动?下面是我的代码,但这不起作用

如何在android中的地图片段内中心线性布局?