算法与数据结构系列之[线性表的顺序存储结构]

最新推荐文章于 2023-10-20 19:52:32 发布
最新推荐文章于 2023-10-20 19:52:32 发布
阅读量137 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： 数据结构 算法 顺序存储结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yelang0/article/details/90488342
版权

在这里插入图片描述
说到线性表的顺序存储结构，我们平时最常用的数组就是顺序存储结构，即用一段地址连续的存储单元依次存储线性表的数据元素。说的通俗一点，就是需要为数组在内存中开辟连续的存储空间。这样连续的存储结构也是优缺点非常明显的，因为数组元素的存储地址是连续的，所以查询起来就很方便，通过数组元素的下标就可以查询到任意的数组元素，且查询的时间复杂度为O(1),对于大数据量的查询性能优势很明显，这也是随机存取的好处。但是数组元素的插入和删除操作的缺点也就很突出了，每插入和删除一个元素，就需要将从该位置起所有的元素向后或向前移动。在最好的情况下，如果元素要插入到最后一个位置，或者删除最后一个元素，此时的时间复杂度为O(1)。最坏的情况是，如果元素要插入到第一个位置或是删除第一个元素，此时的时间复杂度就是O(n)了，插入到第i个位置的平均时间复杂度也是O(n),可以得出数组的插入和删除操作的时间复杂度就是O(n)，所以对于大数据量的数组频繁的插入和删除操作，这样的性能消耗也是很大的，此时使用链表就比使用数组更合适。

C语言代码 （IDE使用的是CLion,至于IDE的配置，大家可以网上找找，不懂的地方可以关注我的微信公众号：源码复兴号，加我微信联系我）：
1、SqList.c

#define INITSIZE 100  //线性表存储空间的初始分配量
#define OK 1
#define ERROR 0
#define LISTINCREMENT 10 //线性表存储空间的分配增量
#define TRUE 1
#define FALSE 0

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef int Status;

def struct {
    ElementType *data;  //声明了一个名为data的长度不确定的数组，也叫“动态数组”
    int length; //记录当前顺序表的长度
    int size; //记录顺序表分配的存储容量
}SqList;
/**
* 初始化顺序表
* @param L
* @return
*/
Status  InitList(SqList *L){
    L->data = (ElementType *)malloc(INITSIZE* sizeof(ElementType));  //分配存储空间为100
    if(!L->data) exit(0); //存储分配失败
    L->length = 0; //初始线性表长度为0
    L->size = INITSIZE; //初始存储容量
    return OK;
}

/**
* 查询第i个位置的元素值，并用e返回
* @param L
* @param i
* @param e
* @return
*/
Status GetElem(SqList L,int i,ElementType *e){
    if(L.length==0 || i<1 || i>L.length)
        return ERROR;
    *e=L.data[i-1];
    return OK;
}

/**
* 在第I的位置插入元素
* @param L
* @param i
* @param e
* @return
*/
Status ListInsert(SqList *L,int i,ElementType e){
    int k;
    if(i<1 || i>L->length+1) //当i不在范围内
        return ERROR;
    if(L->length >= L->size){    //当前的存储空间已满时，增加内存分配
        L->data =(ElementType *)realloc(L->data,(L->size+LISTINCREMENT)* sizeof(ElementType));
        if(!L->data)  //存储分配失败
            exit(0);
        L->size += LISTINCREMENT; //增加存储容量
    }
    if(i<=L->length){
        for (int k = L->length-1; k >=i-1 ; k--) {
            L->data[k+1]=L->data[k];
        }
    }
    L->data[i-1]=e;
    L->length++;
    return OK;
}

/**
* 删除线性表中第i个位置的元素
* @param L
* @param i
* @param e
* @return
*/
Status ListDelete(SqList *L,int i,ElementType *e){
    int k;
    if(L->length == 0)
        return ERROR;
    if(i<1 || i>L->length)  //i的值不合法
        return ERROR;
    *e=L->data[i-1];
    if(i<L->length){
        for (int k = i; k < L->length; k++) {
            L->data[k-1] = L->data[k];
        }
    }
    L->length--;
    return OK;
}

/**
* 判断线性表是否为空
* @param list
* @return
*/
Status ListEmpty(SqList list){
    if(list.length == 0)
        return TRUE;
    return FALSE;
}

/**
* 清空线性表，将线性表L置为一个空表
* @param L
* @return
*/
Status ClearList(SqList *L){
    L->length = 0;
    return OK;
}

/**
* 销毁线性表，释放内存
* @param L
* @return
*/
Status DestroyList(SqList *L){
    if(L->data){
        free(L->data);
        L->data = NULL;
        L->size =0;
        return TRUE;
    }
    return FALSE;
}

/**
* 返回线性表中元素个数
* @param L
* @return
*/
int ListLength(SqList L){
    return L.length;
}

/**
* 返回线性表的内存容量
* @param L
* @return
*/
int ListSize(SqList L){
    return L.size;
}

/**
* 遍历打印线性表元素
* @param L
*/
void DisplayList(SqList L){
    for (int i = 0; i < L.length; i++) {
        printf("%d ",L.data[i]);
    }
}

2、SqList.h

#ifndef TEST_SQLIST_H
#define TEST_SQLIST_H
typedef int ElementType;
typedef int Status;
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef struct {
    ElementType *data;  //声明了一个名为data的长度不确定的数组，也叫“动态数组”
    int length; //记录当前顺序表的长度
    int size; //记录顺序表分配的存储容量
}SqList;

//初始化线性表
Status  InitList(SqList *L);

//查询第i个位置的元素
Status GetElem(SqList L,int i,ElementType *e);

//添加元素
Status ListInsert(SqList *L,int i,ElementType e);

//删除元素
Status ListDelete(SqList *L,int i,ElementType *e);

//判断线性表是否为空
Status ListEmpty(SqList list);

//清空线性表，将线性表L置为一个空表
Status ClearList(SqList *L);

//销毁线性表，释放内存
Status DestroyList(SqList *L);

//返回线性表中元素个数
int ListLength(SqList L);

//返回线性表的内存容量
int ListSize(SqList L);

//遍历打印线性表元素
void DisplayList(SqList L);
#endif //TEST_SQLIST_H

3、main.c

#include <stdio.h>
#include "src/hello.h"
#include "src/data/SqList.h"
int main() {
    //初始化一个具有20个元素的线性表
    SqList list;
    InitList(&list);
    for (int i = 1; i <=20 ; i++) {
        list.data[i-1]=i;
        list.length++;
    }

    //遍历线性表
    DisplayList(list);
    printf("\n");

    //输出线性表的长度，即线性表元素个数
    printf("%d",ListLength(list));
    printf("\n");

    //线性表是否为空
    printf("%d",ListEmpty(list));
    printf("\n");

    //打印线性表中第三个位置的元素
    int num ;
    int *n =&num;
    GetElem(list,3,n);
    printf("%d",*n);
    printf("\n");

    //给线性表添加一个元素，并重新遍历
    ListInsert(&list,5,30);
    DisplayList(list);
    printf("\n");

    //删除线性表指定位置的元素，并重新遍历,并打印出将要删除的元素
    int delete;
    int *d = &delete;
    ListDelete(&list,10,d);
    printf("%d",*d);
    printf("\n");
    DisplayList(list);
    printf("\n");

    //清空线性表
    ClearList(&list);
    DisplayList(list);  //此次遍历线性表中已经没有元素
    printf("\n");
    printf("%d",ListLength(list));  //元素个数为0
    printf("\n");
    printf("%d",ListSize(list));  //此时给线性表分配的内存容量还为100
    printf("\n");

    //销毁线性表,并释放内存
    int result = DestroyList(&list);
    DisplayList(list);  //此次遍历线性表中已经没有元素
    printf("\n");
    printf("%d",ListLength(list));  //元素个数为0
    printf("\n");
    printf("%d",ListSize(list));  //此时给线性表分配的内存容量0
    printf("\n");
    return 0;
}

4、运行结果

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
20
0
3
1 2 3 4 30 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
9
1 2 3 4 30 5 6 7 8 10 11 12 13 14 15 16 17 18 19 20

0
100

0
0

java代码:

public class Array<E>{
    private E[] data;
    private int size;

    /**
     * 构造函数，传入数组容量capacity构造array
     * @param capacity
     */
    public Array(int capacity){
        data = (E[]) new Object[capacity];
        size = 0;
    }

    /**
     * 无参构造，数组的容量默认为100
     */
    public Array(){
        this(10);
    }

    public Array(E[] arr){
        data = (E[]) new Object[arr.length];
        for (int i = 0; i < arr.length; i++) {
            data[i] = arr[i];
        }
    }
    /**
     * 获取数组的元素个数
     * @return
     */
    public int getSize(){
        return size;
    }

    /**
     * 获取数组容量
     * @return
     */
    public int getCapacity(){
        return data.length;
    }

    /**
     * 判断数组是否为空
     * @return
     */
    public boolean isEmpty(){
        return size == 0;
    }

    /**
     * 向数组指定位置插入元素
     * @param index
     * @param e
     */
    public void add(int index,E e){
        if(index<0 || index>size){
            throw  new IllegalArgumentException("下标越界");
        }
        if(size == data.length){
            resize(2*data.length);
        }
        for(int i=size-1;i>=index;i--){
            data[i+1] = data[i];
        }
        data[index] = e;
        size++;
    }

    /**
     * 向数组的第一个位置添加元素
     * @param e
     */
    public void addFirst(E e){
        add(0,e);
    }

    /**
     * 向数组的最后一个位置添加元素
     * @param e
     */
    public void addLast(E e){
        add(size,e);
    }

    /**
     * 当数组容量已满时自动扩容2倍
     * @param newCapacity
     */
    private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity];
        for (int i = 0; i <size ; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    /**
     * 向数组中插入元素
     * @param e
     */
    public void add(E e){
        add(size,e);
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d , capacity = %d\n",size,data.length));
        res.append("[");
        for (int i = 0; i <size ; i++) {
            res.append(data[i]);
            if(i != size-1){
                res.append(",");
            }
        }
        res.append("]");
        return res.toString();
    }

    /**
     * 查询指定位置的数组元素
     * @param index
     * @return
     */
    public E get(int index){
        if(index < 0 || index > size){
            throw new IllegalArgumentException("传入的数组索引值不合法");
        }
        return data[index];
    }

    /**
     * 查询数组的第一个元素
     * @return
     */
    public E getFirst(){
        return get(0);
    }

    /**
     * 查询数组的最后一个元素
     * @return
     */
    public E getLast(){
        return get(size-1);
    }

    /**
     * 修改数组指定位置的元素
     * @param index
     * @param e
     */
    public void set(int index,E e){
        if(index < 0 || index > size){
            throw new IllegalArgumentException("传入的数组索引值不合法");
        }
        data[index] = e;
    }

    /**
     * 查询数组中是否包含某个元素e
     * @param e
     * @return
     */
    public boolean contains(E e){
        for (int i = 0; i <size; i++) {
            if(data[i] == e){
                return true;
            }
        }
        return false;
    }

    /**
     * 查询并返回某个元素e的下标
     * @param e
     * @return
     */
    public int find(E e){
        for (int i = 0; i < size; i++) {
            if(data[i] == e){
                return i;
            }
        }
        return -1;
    }

    /**
     * 删除指定索引值的元素，并返回该元素
     * @param index
     * @return
     */
    public E remove(int index){
        if(index<0 || index>size){
            throw  new IllegalArgumentException("所传入的数组索引值不合法");
        }
        E ret = data[index];
        for (int i = index + 1; i <size ; i++) {
            data[i-1] = data[i];
        }
        data[--size] = null;
        if(size == data.length/4 && data.length/2 !=0){
            resize(data.length/2);
        }
        return ret;
    }

    /**
     * 删除数组的第一个元素
     * @return
     */
    public E removeFirst(){
        return remove(0);
    }

    /**
     * 删除数组的最后一个元素
     * @return
     */
    public E removeLast(){
        return remove(size-1);
    }

    /**
     * 从数组中删除元素e
     * @param e
     */
    public boolean removeElement(E e){
        int index = find(e);
        if(index != -1){
            remove(index);
            return true;
        }
        return false;
    }

    /**
     * 数组元素交换
     * @param i
     * @param j
     */
    public void swap(int i,int j){
        if(i < 0 || i >= size || j < 0 || j >= size)
            throw new IllegalArgumentException("非法索引");
        E temp = data[i];
        data[i] = data[j];
        data[j] = temp;

    }
}

微信公众号：
在这里插入图片描述

秦老厮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Nuttx watchdog 看门狗
chengwenyang的专栏
04-18 1349
看门狗是Nuttx中实现的一种定时器，该定时器底层基于硬件定时器，通过设置硬件定时器的定时触发来驱动看门狗。看门狗为系统提供了精确定时执行回调任务的机制。注册底层硬件定时器注册硬件定时器系统在启动初始化过程中，通过void up_initialize(void)函数调用void up_initialize(void)，在up_initialize()函数中初始化硬件定时器，作为watchdog的底层
线性表顺序存储运算的算法实现
09-03
本话题将深入探讨线性表的顺序存储结构及其在C语言中的算法实现，包括线性表的输入输出、插入、删除以及长度和置空操作。 1. **线性表的顺序存储结构** 在顺序存储结构中，线性表的元素在内存中以数组的形式存储，...
算法&数据结构 - 线性表及其顺序存储结构
爱意随风起，风止意难平
07-10 1802
本篇主要介绍线性表相关理论及实例，包括线性表增删操作，顺序存储结构及其操作，本篇中量代码。
数据结构之线性表之线性表顺序存储结构
m0_74018560的博客
12-10 684
数据结构之线性表部分之线性表存储结构
数据结构与算法——线性表的顺序存储
落子无悔的博客
07-30 1280
数据结构与算法——线性表的顺序存储方式
【数据结构】线性表的顺序存储
DAY I 的成长之路
04-24 4088
💯线性表是具有相同类型的数据类型的n个数据元素的有限序列，其中n为表长，n0n=0n0时为空表ege.geg这里要注意的是，定义中描述的为数据元素，而非数据项，也就是，存储单元可以是一个结构体，而数据项为里面的成员✨线性表的特点：表中元素的个数为有限个表中元素具有逻辑上的顺序性，表中元素有其先后顺序表中元素都是数据元素，每一个元素都为单个元素表中元素的数据类型都相同，每个元素占相同的内存空间表中元素具有抽象性，即仅讨论元素之间的逻辑关系，而不考虑具体实现方式🔑。
【数据结构】线性表的顺序存储结构
最新发布
C/C++领域,数据结构,linux,MySQl学习者
10-20 549
数据结构线性表篇(第3小节)学习笔记:线性表的顺序存储结构.内容包括:顺序存储定义,顺序存储方式,数组长度与线性表长度的区别,地址计算方法等相关知识.
数据结构与算法——线性表的顺序存储结构
weixin_68773927的博客
10-17 1222
为了确定记录在表中的位置，需要与给定元值进行比较的关键字的个数的期望值叫做查找算法的平均查找长度。2.平均查找长度ASL（Average Search Length）顺序表必须用连续空间，只能插入到最后一个元素后面。插入元素在最前面：从第一个元素开始向后移动。插入位置在中间： 从最后一个元素向后移动。ci 找到第i个记录需要比较的次数。时间复杂度: T(n)=O(n)时间复杂度T(n)=O(n)空间复杂度：S(n)=O(1)pi 第一个记录被查找的概率。
数据结构—线性表顺序存储与链式存储结构操作
LeGuan_Ha的博客
11-10 1512
数据结构中，关于线性表两种存储方式，分别是顺序存储与链式存储，本文章主要是关于两种方式结构定义以及涉及的基本操作。
数据结构与算法——线性表的顺序储存结构
xzt12138的博客
07-20 6992
顺序储存结构就是在内存中找了一块地，将一组数据以连续的方式将其储存在这块内存中。而且每个元素的数据类型相同，所以我们可以用C语言的一维数组来实现顺序储存结构。即，把第一个数据元素存到下标为0的位置，接着把线性表相邻的元素储存在数组中相邻的位置。......
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
python数据结构之线性表的顺序存储结构
12-24
用Python仿照C语言来实现线性表的顺序存储结构，供大家参考，具体内容如下 本文所采用的数据结构模板为 《数据结构教程》C语言版，李春葆、尹为民等著。 该篇所涉及到的是线性表的顺序存储结构。 代码： # !/usr/...
数据结构与算法－线性表顺序存储及其相关算法 定义线性表节点的结构.pdf
04-18
"数据结构与算法－线性表顺序存储及其相关算法" 本资源主要介绍了线性表顺序存储的概念和相关算法，包括顺序表的优缺点、插入、删除、定位等操作的实现和分析。 1. 顺序表的优点包括：不需要为表示结点间的逻辑...
dm02_线性表顺序存储设计与实现.zip_数据结构 线性表
09-21
总的来说，这个压缩包中的代码提供了线性表顺序存储的一个基础实现，是学习和理解数据结构及算法的好例子。通过阅读和分析这段代码，你可以深入理解线性表的概念，以及如何用C语言高效地实现其基本操作。
算法与数据结构系列之[优先队列]
yelang0的博客
07-09 1502
前面我们介绍了队列这种数据结构，不过我们在前面所介绍的队列只是一种普通的队列，即元素先进先出，其实队列还可以分优先级，优先级高的元素先出，比如操作系统的调度，会将优先级高的任务先调度执行，这种队列就叫做优先队列。 那么优先队列底层该如何实现呢？ 1.优先队列可以使用普通的线性结构，比如动态数组，入队时的时间复杂度为O(1),出队时需要遍历元素，找到优先级最大的元素出队，时间复杂度为O(n)。 2....
算法与数据结构系列之[哈希表]
yelang0的博客
07-09 1236
前言 前面我们介绍线性表的时候，如果要查找某个元素，比如key,就需要从表头开始，逐个比较记录a[i]和key的值是相等还是不相等，知道有相等才算查找成功，返回i。那么我们有没有一种方法不用逐个比较就能查找到要查询的元素呢？答案是肯定的，我们可以通过关键字key得到要查找记录的内存位置，这就是我们这篇要介绍的哈希表，其实哈希表算是线性存储结构的范畴，因为哈希表用到数组作为存储结构。 1.什么是哈希...
算法与数据结构系列之[平衡二叉树-AVL树-下]
yelang0的博客
07-09 575
上篇介绍了AVL树的概述，这篇把AVL树的java代码实现贴出来 public class AVLTree<K extends Comparable<K>, V> { private class Node{ public K key; public V value; public Node left, right; ...
算法与数据结构系列之[平衡二叉树-AVL树-上]
yelang0的博客
07-09 541
1.问题概述 我们在介绍二分搜索树的时候提到时间复杂度为O(logn),但是这并不是绝对的，有些时候树可能退化为链表，时间复杂度回到O(n)级别，所以为了性能考虑，应尽量避免这种退化，这就用到了平衡树。 2.什么是平衡二叉树 平衡二叉树的定义是，对于任意一个节点，左子树和右子树的高度差不能超过1，且平衡二叉树的高度和节点的数量之间的关系一是O(logn)的。我们前面介绍的满二叉树、完全二叉树和线...
数据结构与算法解析：线性表的顺序存储与插入操作
本节主要讨论顺序存储结构，它将线性表中的元素存储在内存中地址连续的一段空间里，逻辑上相邻的元素在物理位置上也相邻，这有助于快速访问相邻元素。顺序表的操作效率往往取决于元素的物理位置，例如，插入和删除...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值