线性表的认识（源码分析）

最新推荐文章于 2021-10-19 17:23:19 发布
最新推荐文章于 2021-10-19 17:23:19 发布
阅读量182 收藏 1
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40749830/article/details/105754156
版权

文章目录

一、线性表的认识

  1. 线性表是n个数据类型相同的数据元素的组成的序列。一般表示方式{n1,n2,n3,…n}.特定如下。
    • 相同的数据类型：在内存存储时，每个元素占用的空间大小相同，有利于对元素操作。
    • 序列是有顺序的：除最前和最后一个元素为，每个元素只有且仅有一个前驱，一个后继。
    • 有限：每个线性表的长度有限。序号从0开始。

例子：学号。

二、存储结构

1、 顺序表—>顺序存储结构

在这里插入图片描述

特点：1. 在内存中分配连续的空间，只存储数据，不存储地址信息，位置就隐含着地址。

优点：1. 索引查询效率高，可以根据每个元素分配的地址间隔查找。

缺点：1. 插入和删除，比较麻烦，需要移动元素，效率较低。

		2. 必须提前分配空间。元素个数不确定性。容易**浪费空间**。
		3. 查询指定元素的时间比较久。一位数组的时间复杂度为O(n)。

2、链表—>链式存储结构

在这里插入图片描述

特点：1. 数据元素存储对应的是不连续的存储空间，每个节点分别存储数据域，和指针域。每个元素的指针域存储的是下一个节点的地址。

优点：1. 插入，删除灵活(不必移动节点，只有改变指针指向的元素地址就行。)

​ 2. 在某种程度上节省空间，不需要提前分配空间。不会有闲置空间。

缺点：1. 存储的元素不紧凑，也就是说，相通一段地址，没有顺序表存储的元素多。

  1. 索引查询效率低，因为存储时不连续的的，不知道元素所在的地址。

三、顺序表代码实现

1、包含内容

下面自定义代码，大部分都是模仿源码java.util.ArrayLIst仿写。

其中自定义接口中包含有：属性表的增加、删除、替换、查找等一系列对顺序表的操作。

其中有涉及一些LIst容器的默认大小，怎样扩容，何时扩容，以那种形式扩容，扩容多大，边界判断，异常信息，复制数组等，底层代码。有的代码没有仔细研究，有兴趣的小伙伴可以自行查看源码。

2、自定义List接口

package com.gwz.datastructure.linetable;

/**
 * 线性表接口
 * @author gwz
 */
public interface List<E> {
    // 返回线性表的大小，数据元素的个数。
    int size();

    // 返回线性表中序列号（下标）为 i 的数据元素。
    Object get(int i);

    // 判断线性表是否为空，为空返回true,否则返回false。
    boolean isEmpty();

    // 判断线性表是否包含数据元素 e
    boolean contains(Object e);

    // 返回数据元素 e 在线性表中的下标
    int indexOf(Object e);

    // 将数据元素 e 插入线表中 i 号（下标）位置
    void add(int i, Object e);

    // 将数据元素e 插入到线性表末尾
    boolean add(Object e);

    // 将数据元素 e 插入到数据元素obj 之前
    boolean addBefore(Object obj, Object e);

    // 将数据元素 e 插入到数据元素obj 之后
    boolean addAfter(Object obj, Object e);

    // 删除线性表中下标 为 i 的元素，并返回。
    Object remove(int i);

    // 删除线性表中第一个与 e 相同的元素
    boolean remove(Object e);

    // 替换线性表中下标为 i 的数据元素为e ,并返回原数据。
    Object replace(int i, Object e);

    // 转换成数组
    Object[] toArray();
    
    // 数组字符串输出
    String toString();
}

3、自定义ArrayList实现类

package com.gwz.datastructure.linetable;

import java.util.Arrays;

/**
 * 顺序表
 * 底层采用数组，长度可以动态变化
 */
public class ArrayList<E> implements List<E> {

    // 默认初始化容量
    private static final int DEFAULT_CAPACITY = 10;
    private static final int MAX_ARRAY_SIZE =  Integer.MAX_VALUE - 8;

    //底层是一个数组，目前没有分配空间，当添加第一个元素是，会自动扩展为一定的容量，源码是10。
    private Object[] elementData;

    // 空实例，共享空数组的实例
    private static final Object[] EMPTY_ELEMENTDATA = {};

    // 和空实例区分，用来了解什么时候扩充容量当添加第一个元素。
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    // 不是数组分配的空间，而是数组元素的个数。
    private int size;

    public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;}

    public ArrayList(int initialCapacity) {
        if(initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
        }
    }
    @Override
    public int size() {
        return size;
    }

    @Override
    public Object get(int i) {
        rangeCheck(i);
        return elementData(i);
    }

    // 获取元素，没有检查下标范围
    E elementData(int i) {
        return (E) elementData[i];
    }

    // 下标范围检查
    private void rangeCheck(int i) {
        if (i >= size) {
            throw new IndexOutOfBoundsException(outOfBoudsMsg(i));
        }
    }

    // 下标异常信息
    private String outOfBoudsMsg(int i) {
        return "Index: "+ i + ",Size:" + size;
    }

    @Override
    public boolean isEmpty() {
        return size ==0;
    }

    @Override
    public boolean contains(Object e) {
        return indexOf(e) >= 0;
    }

    @Override
    public int indexOf(Object e) {
        if (e == null){
            for (int i = 0; i < size; i++) {
                if (elementData[i] == null)
                    return i;
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (e.equals(elementData[i]))
                    return i;
            }
        }
        return -1;
    }

    @Override
    public void add(int i, Object e) {
        rangeCheckForAdd(i);
        // 确保有足够测存储空间
        ensureCapacityInternal(size+1);
        System.arraycopy(elementData, i, elementData, i+1, size - i);
        elementData[i] = e;
        size++;
    }

    // 为添加元素判断下标范围
    private void rangeCheckForAdd(int i) {
        if (i> size || i < 0)
            throw new IndexOutOfBoundsException(outOfBoudsMsg(i));
    }

    @Override
    public boolean add(Object e) {
        // 判断容器大小
        ensureCapacityInternal(size+1);
        elementData[size++] = e;
        return true;
    }

    // 确保容器大小能够添加
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    // 确保容器的存储容量
    private void ensureExplicitCapacity(int minCapacity) {
        // 这里不考虑列表被修改的次数

        // 最大需要容量大于当前容器容量，需要扩容
        if(minCapacity - elementData.length > 0){
            grow(minCapacity);
        }
    }

    // 容器扩容，确保能够存储  minCapacity为需要的最小容量
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);

    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
    }

    // 计算容器大小
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

    @Override
    public boolean addBefore(Object obj, Object e) {
        int index = indexOf(obj);
        if (index >= 0 ) {
            ensureCapacityInternal(size+1);
            System.arraycopy(elementData, index, elementData, index+1, size-index);
            elementData[index] = e;
            size++;
            return true;
        }
        return false;
    }

    @Override
    public boolean addAfter(Object obj, Object e) {
        int index = indexOf(obj);
        if (index >= 0 ) {
            ensureCapacityInternal(size+1);
            System.arraycopy(elementData, index+1, elementData, index+2, size-index-1);
            elementData[index+1] = e;
            size++;
            return true;
        }
        return false;
    }

    @Override
    public Object remove(int i) {
        rangeCheckForAdd(i);
        E oldValue = elementData(i);

        int numMoved = size - i -1;
        if (numMoved >0)
            System.arraycopy(elementData,i+1, elementData, i, numMoved);
        elementData[--size] = null;
        return oldValue;
    }

    @Override
    public boolean remove(Object e) {
        if (e == null){
            for (int i = 0; i < size; i++) {
                if (elementData[i] == null) {
                    fastRemove(i);
                    return true;
                }
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (e.equals(elementData[i])) {
                    fastRemove(i);
                    return true;
                }
            }
        }
        return false;
    }

    // 跳过边界检查， 而不跳过返回删除的值
    private void fastRemove(int i) {
        int numMoved = size - i - 1;
        if (numMoved > 0 ) {
            System.arraycopy(elementData, i+1, elementData, i, numMoved);
        }
        elementData[--size] = null;
    }

    @Override
    public Object replace(int i, Object e) {
        rangeCheckForAdd(i);
        elementData[i] = e;
        return elementData[i];
    }

    @Override
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }
    
     @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        if (size == 0) {
            return "[]";
        }
        sb.append('[');
        for (int i = 0; i < size; i++) {
            if (i != size -1 ) {
                sb.append(elementData[i] + ",");
            } else {
                sb.append(elementData[i]);
            }
        }
        sb.append(']');
        return sb.toString();
    }
}

四、单链表代码实现

1、单链表概念

在这里插入图片描述

单链表的一个重要特点就是这能通过前驱结点找到后继结点，不能通过后继结点找到前驱结点。

package com.gwz.datastructure.linetable;

/**
 * 单链表的结点
 */
public class Node {

//    private Object data;
//    private Node next;
    // 这里定义成这样，是为了方便在同一包内直接访问。
    Object data;
    Node next;

    public Node() {
    }

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

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

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}

2、单链表的查询，添加，删除操作

1、查询操作

对比顺序表，单链表的查询操比较麻烦，需要一个一个比较，同时还有移动指针，没有索引的帮助，效率比较低。
在这里插入图片描述

2、添加操作

添加结点，需要先找到添加的位置，然后移动指针就可以，这个操作相对来说简单一点。
在这里插入图片描述

3、删除操作

删除与添加类型，也是删除之后，移动指针。

在这里插入图片描述

3、单链表代码实现

为了操作方便，简化编码，我们通常会在单链表前面添加一个亚元结点，也称为头结点，使我们操作后面的任何一个结点的处理方式相同。不用做特殊处理。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tppX2G2C-1587810137829)(D:\数据结构的学习\线性表\1587783711952.png)]

*代码实现

package com.gwz.datastructure.linetable;

/**
 * 单链表
 *
 * @param <E>
 */
public class SingleLinkedList<E> implements List<E> {

    // 头结点，不存储数据，简化编程。
    private Node head = new Node();

    // 结点的个数。
    private int size;

    @Override
    public int size() {
        return size;
    }

    @Override
    public Object get(int i) {
        Node p = head;
        rangeCheck(i);
        for (int j = 0; j <= i; j++) {
            p = p.next;
        }
        return p.data;
    }

    // 范围检查
    private void rangeCheck(int i) {
        if (i > size) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(i));
        }
    }

    // 下标异常信息
    private String outOfBoundsMsg(int i) {
        return "异常下标：Index: "+ i + ",Size:" + size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean contains(Object e) {
        return false;
    }

    @Override
    public int indexOf(Object e) {
        Node p = head;
        if (e == null){
            for (int i = 0; i < size; i++) {
                if (p.next.data == null)
                    return i;
                else
                    p = p.next;
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (e.equals(p.next.data))
                    return i;
                else
                    p = p.next;
            }
        }
        return -1;
    }

    @Override
    public void add(int i, Object e) {
    	rangeCheckForAdd(i);
        // 找到指定位置的前一个结点，从head开始查找
        Node p = head;
        for (int j = 0; j < i; j++) {
            p = p.next;
        }
        // 新创建一个结点
        Node q = new Node();
        q.data = e;
        // 指明新结点直接的后继
        q.next = p.next;
        // 指明新结点直接的前驱
        p.next = q;
        // 改变数量
        size++;
    }

    @Override
    public boolean add(Object e) {
        add(size, e);
        return true;
    }

    @Override
    public boolean addBefore(Object obj, Object e) {
        return false;
    }

    @Override
    public boolean addAfter(Object obj, Object e) {
        return false;
    }

    @Override
    public Object remove(int i) {
        return null;
    }

    @Override
    public boolean remove(Object e) {
        Node q = (Node) e;
        Node p = head;
        if (q.data == null){
            for (int i = 0; i < size; i++) {
                if (p.next.data == null) {
                    p = p.next.next;
                    size--;
                    return true;
                }
                p = p.next;
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (((q.data).equals(p.next.data))) {
                    if(i == size -1) {
                        p = p.next;
                    } else {
                        p = p.next.next;
                    }
                    head.next = p; // 这里注意，要用户head重新指向单链表
                    --size;
                    return true;
                }
                p = p.next;
            }
        }
        return false;
    }

    @Override
    public Object replace(int i, Object e) {
        Node q = (Node) e;
        rangeCheckForAdd(i);
        Node p = head;
        for (int j = 0; j <= i; j++) {
            p = p.next;
        }
        p.data = q.data;
        return head;
    }

    // 添加元素是判断下标是否越界
    private void rangeCheckForAdd(int i) {
        if (i> size || i < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(i));
    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public String toString() {
        Node p = head;
        StringBuilder sb = new StringBuilder();
        if (size == 0) {
            return "[]";
        }
        sb.append('[');
        for (int i = 0; i < size; i++) {
            if (i != size -1 ) {
                sb.append(p.next.data + ",");
            } else {
                sb.append(p.next.data);
            }
            p = p.next;
        }
        sb.append(']');
        return sb.toString();
    }
}

五、其他链表

1.双向链表

双向链表拥有两个指针域，一个是指向前驱，一个指向后继。

java中的LinkedList底层使用的就是双向链表。

在这里插入图片描述

2、循环链表

双向循环链表。

在这里插入图片描述

六、java中的线性表

Vector 线程安全，现在已经淘汰。一倍扩容，可以看底层源码grow方法

ArrayList：提高了性能，线程不安安全。

LinkedList：双链表。

有关ArrayList 和 LinkedLIst的研究探讨参考

1、双向循环链分析

在这里插入图片描述

+小志+9
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表代码总结
FEEL的博客
11-01 1086
文章目录1. 线性表的结构体定义1.1 顺序表的结构体定义1.2 单链表结点定义1.3 双链表结点定义2. 顺序表的操作 1. 线性表的结构体定义 1.1 顺序表的结构体定义 #define maxSize 100 //整型常量 typedef struct{ int data[maxSize]; //存放顺序表元素的数组 int length; //存放顺序表的长度 ...
线性表C++源码.rar
04-09
C++描述线性表，通过使用模板，写成通用的模板类，代码调试通过。描述了线性表的顺序存储和链式存储结构，并且富有测试代码，帮助初学者进行感性认知。
线性表详解（附代码）
羽的博客
05-15 2840
文章目录最简单的结构：线性表线性表的概念操作顺序表1、定义顺序表结构2、定义顺序表的操作3、初始化顺序表4、顺序表的长度5、添加节点6、插入节点7、删除节点8、按序号查找节点9、按照关键字查找节点10、遍历顺序表：运用实例： 最简单的结构：线性表 线性表有两种形式： 顺序线性表 链式线性表 线性表的概念 ​ 由若干个数据组成的集合可以看做是一个线性表。线性表中的数据元素之间的关系是一对一，即除了第一个和最后一个元素外，其他元素都是首尾相接的。例如学生的学号组成的数据就是一个线性表。如下图： 20
线性表 详细分析与源码
qq_42824207的博客
10-04 116
线性表 了解线性表的逻辑结构定义。 掌握线性表的顺序结构实现，以及顺序结构下基本操作的实现，能写出操作代码。 掌握线性表的链式结构实现，以及链式结构下基本操作的实现，能写出操作代码。 能够设计针对顺序结构和链式结构线性表的一般应用问题的算法，能写出算法代码。 掌握栈的基本概念、栈的性质。 掌握栈的顺序结构和链式结构实现，以及相应操作的实现，能够写出操作代码。 了解栈与递归的关系，能够编写递归算法，能够将递归算法转换为非递归形式。 掌握队列的基本概念和性质。
线性表的源码分析
Jack11998的博客
07-14 253
线性表 在我们刚开始学习数据结构的过程中，往往是从数据结构的历史开始学起，然后是什么是算法，算法的特性等，接下来便是复杂度的分析。 因为写这个博客我的初衷是对每章的源码进行剖析，以便于自己能够更好的学习这门课，掌握其思想。在这里笔者只希望大家不要去死学数据结构。数据结构是一切算法的思想，它本身就非常有趣，当然也可以学的很开心。 顺序表 我来先讲一下顺序表的思想。 咱们举个例子来阐述，中学的时候大家应该都会做广播体操的吧，在做广播体操之前，我们往往会先排队，你的前面是谁，后面是谁，一般都是会固定好。
线性表（代码、分析、汇编）
万事亨通
12-28 149
目录：代码：分析：汇编： 代码： LinkList.h #ifndef _LINKLIST_H_ #define _LINKLIST_H_ typedef void LinkList; //定义线性表类型 typedef struct _tag_LinkListNode LinkListNode;//定义线性表节点类型 struct _tag_LinkListNode { LinkListNode* next;//节点指针指向下一个节点 }; LinkList* LinkList_Create(
线性表实现源码-java
01-22
java实现的简单线性表结构，包含顺序存储结构和单向链式存储结构的源码
线性表的认识
06-14
总结的线性表知识，希望大家难呢过学到编程。线性表是最基本、最简单、也是最常用的一种数据结构。 线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的...
数据结构（线性表）源码
10-04
数据结构（线性表）源码 数据结构（线性表）源码 数据结构（线性表）源码 数据结构（线性表）源码 数据结构（线性表）源码
线性表之连续存储(数组)源码
12-02
数据结构的数组源码,基本的方法已经实现了,供初学者参考
线性表
07-17
insert_sqlist,delete_sqlist,locate_sqlist
线性表的代码
12-02
线 性 表 的 代 码， 用 C ++ 语 言 实 现。
线性表代码实现
qinjiawei_156558的博客
07-25 1965
如题；这是一套完整的可运行的代码；需要读者有一定的基础去阅读； 语言是用C语言实现；在C++环境中编写；在C++中可直接运行；在C语言中需要改部分头文件和输出语句； 头文件；这要是代码的声明部分； # ifndef _SEQLIST_ # define _SEQLIST_ # include <iostream> using namespace std; # define ...
数据结构-线性表-顺序表的代码详解
飞鸟无痕丶的博客
10-23 1720
数据结构中的一大重点   线性表： 一。顺序表      数据存储是连续的，有多少数据开辟多少储存空间，所以不存在资源浪费      查找速度快，但是在增删数据的时候可能会移动大量数据，所以增删操作速度慢 二。链表    数据存储是离散的，所以数据的存储不连续，无规则，可能存在空间大于数据数目，浪费资源      但是增加跟删除元素的时候不影响其他元素，速度快    根据划分条件不同： ...
线性表之链表源代码
Fighting_Dream
09-30 1425
//链表 #include #include using namespace std; typedef struct LNode { int data; struct LNode *next; }LNode,*LinkList; int InitList_L(LinkList &L) { L=new LNode; L->next=NULL; return 1; } void Inpu
线性表完整代码
weixin_30760895的博客
07-30 5414
顺序存储： #include<stdio.h> #include<stdlib.h> typedef int Position; typedef int ElementType; typedef struct LNode *PtrToLNode; #define MAXSIZE 10 struct LNode{ Elem...
python数据结构——线性表
dimuqiang9477的博客
09-08 319
线性表 线性表可以看作是一种线性结构（可以分为顺序线性结构，离散线性结构） 1. 线性表的种类： 顺序表 元素存储在一大块连续存储的地址中，首元素存入存储区的起始位置，其余元素顺序存放。 （元素之间的逻辑关系与物理地址上相邻的关系相同） 链接表： 将表元素存放在通过链接构造的一系列存储块中 （元素的物理位置不相邻） 2. 顺序表的实现 顺序表的实现 思路： $$ Loc(e_...
最详细线性表知识点附加代码来了！
cnchouchou的博客
10-19 416
线性表 线性表的抽象数据类型： InitList(*L):初始化操作，建立一个新的线性表 ListEmpty(L):判断线性表是否为空，如果为空返回True，否则返回False ClearList(*L)：将线性表清空 GetElem(L, i, *e): 将线性表中第i个元素返回给e LocateElem(L, e):在线性表中查找与给定e值相等的元素，如果查找成功，返回该元素在表中的序号表示成功，否则，返回0表示失败 ListInsert(*L, i, e):在线性表第i个位置插入新元素e ListDe
八大排序类型（详解）
qq_40749830的博客
05-03 8114
文章目录一、排序基本概念1、什么是排序？2、内部排序和外部排序3、稳定排序4、排序类型5、排序效率二、交换排序1、冒泡排序2、快速排序三、选择排序四、插入排序五、各种排序比较 一、排序基本概念 1、什么是排序？ 排序就是将一个任意序列的一组数据，按某个关键字，重新排列为有序的序列。 2、内部排序和外部排序 内部排序：内部排序就是整个排序过程在内存储器中进行。 外部排序：简单来说，就是数据量太大。内...
c语言线性表子系统分析
最新发布
03-22
C语言线性表子系统是一种数据结构，它可以用来存储一组有序的数据元素。它包括线性表的定义、基本操作和实现方式等内容。线性表的定义是指线性表的基本概念和特性，包括线性表的元素、长度、位置等。基本操作包括...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值