四、【线性表】线性表的顺序表示和实现

于 2021-05-26 12:23:11 发布
阅读量866 收藏 6
点赞数 2
分类专栏： 算法与数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fujz123/article/details/117283543
版权

线性表的顺序表示和实现

前文我们提到过线性表是逻辑结构，只说明了数据元素之间的相互关系，想要使用线性表，我们还需要在计算机上表示出这些数据元素以及元素之间的关系。而对于同一种逻辑结构，可以有多种存储结构来实现它。线性表作为一种基础的数据结构，可以用顺序存储和链式存储两种不同方式来实现，本节主要说明线性表的顺序表示。


1 线性表的顺序表示

1.1 顺序表的定义

线性表的顺序存储又称为顺序表， 它是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。顺序表的特点是表中元素的逻辑顺序与其物理顺序相同。顺序表是一种存储结构，关注的是如何在计算机中存储数据元素及其关系。


1.2 顺序表的特点

假设线性表的每个元素需占用 l l l 个存储单元，并以所占的第一个单元的存储地址作为数据元素的存储位置。则线性表中第 i + 1 i+1 i+1 个数据元素的存储位置 L O C ( a i + 1 ) LOC(a_i+1) LOC(ai​+1) 和第 i i i 个数据元素的存储位置 L O C ( a i ) LOC(a_i) LOC(ai​) 之间满足下列关系：
L O C ( a i + 1 ) = L O C ( a i ) + l LOC(a_i+1) = LOC(a_i) +l LOC(ai​+1)=LOC(ai​)+l
一般来说，线性表的第 i i i 个数据元素 a i a_i ai​ 的存储位置为：
L O C ( a i ) = L O C ( a 1 ) + ( i − 1 ) ∗ l LOC(a_i) = LOC(a_1) +(i-1)*l LOC(ai​)=LOC(a1​)+(i−1)∗l
其中 L O C ( a 1 ) LOC(a_1) LOC(a1​) 是线性表的第一个数据元素 a 1 a_1 a1​ 的存储位置，也被称为线性表的起始位置或基地址。
在这里插入图片描述
观察上图我们可以发现，顺序表的每一个数据元素的存储位置都和线性表的起始位置相差一个和数据元素在线性表中的位序成正比的常数。由此，只要确定了存储线性表的起始位置，表中任一数据元素都可以随机存取（也称为直接访问），所以线性表的顺序存储结构是一种随机存取的存储结构。更广泛地说，顺序存储一般对应随机存取。

总结
顺序表有以下主要特点：

  • 随机存取，读取（或查找）操作时间复杂度为 O ( 1 ) O(1) O(1) 。
  • 存储密度高，每个节点只存储数据元素。
  • 逻辑上相邻的元素物理上也相邻，因此插入和删除操作需要移动大量元素。

2 顺序表的实现

由于高级程序语言中的数组类型也有随机存取的特性，因此通常用数组来描述数据结构中的顺序存储结构。

下文的默认实现语言为C++，因此一切未注明的语法都以C++为准。


2.1 定义

C++中的一维数组可以是静态分配的，也可以是动态分配的。详情见C++动态数组。

  • 静态分配时，由于数组的大小和空间已经事先决定了，一但空间占满，再加入新的数据就会产生溢出，导致程序崩溃。

    /*** 静态数组实现顺序表的类型定义 ***/
#define  MaxSize 10

typedef int elemType; 		// 定义新的类型elemType
typedef struct{
	elemType data[MaxSize]; // ElemType为指定元素类型
	int length;
} SqList;

  • 动态分配就不存在这样的问题，一旦空间占满，就另外开辟一块更大的存储空间，用以替换原来的空间。但要注意的是，动态分配并不是链式存储，它同样属于顺序存储结构，依然是随机存取的方式。但是动态数组需要用户显式地释放内存。

    /*** 动态数组实现顺序表的类型定义 ***/
#define InitSize 50			// 线性表存储空间的初始分配量
#define Increment 10		// 线性表存储空间的分配增量

typedef int elemType; 		// 定义新的类型elemType
typedef struct{			
	elemType *data;			// 存储空间基地址
	int capacity, length	// 当前分配的最大容量和数组长度
} SqList

2.2 主要操作的实现

在顺序存储下，容易实现线性表的某些操作，如随机存取第 i i i 个元素等，因此这里只讨论顺序表较复杂的插入、删除和按值查找操作。

因为静态数组的局限性较大，后文正文内皆以动态数组实现为例展示代码，静态数组实现将放于文末附录。


2.2.1 插入操作

在顺序表 L L L 的第 i ( 1 ≤ i ≤ L . l e n g t h + 1 ) i (1 \le i \le L.\mathrm{length+1}) i(1≤i≤L.length+1) 个位置插入新元素 e e e。若 i i i 的输入不合法，则返回 false，表示插入失败；否则，将第 i i i 个元素及其后的所有元素依次往后移动一个位置，顺序表长度增加1，返回 true 。

/*** 动态数组顺序表实现插入操作 ***/
// 扩容操作
void increment(SqList &L){
    elemType *data = new elemType[L.capacity+Increment];   // 重新申请内存
    for (int i=0;i<L.capacity;i++){                        // 将原来的元素移动到新的顺序表中
        data[i] = L.data[i];
    }
    delete[] L.data;                                       // 释放内存
    L.data = data;
    L.capacity += Increment;
    printf("Finish Increment.\n");
}

// 插入操作
bool listInsert(SqList &L, int i, elemType e){
    if (i<1 || i>L.length+1){               // 判断i的范围是否有效
        printf("Index is illegal!\n");
        return false;
    }   
    if (L.length >= L.capacity){            // 判断存储空间是否还有剩余,
        printf("Need Increment.\n");
        increment(L);                       // 不够则扩容
    }
    for (int j=L.length;j>=i;j--){          // 将位置i及之后的元素向后移动一位
        L.data[j] = L.data[j-1];
    }
    L.data[i-1] = e;
    L.length++;
    return true;
}

时间复杂度分析

对插入操作来说，插入元素只需要一步，而移动元素可能重复很多次，所以基本操作为移动元素。我们只需要关心每一次插入操作发生时，总共移动了多少个元素，而移动元素的个数取决于插入新元素的位置。

  • 最优情况：在表尾插入（即 i = n + 1 i = n+1 i=n+1），元素不用后移，时间复杂度为 O ( 1 ) O(1) O(1)。
  • 最差情况：
    • 静态数组：在表头插入（即 i = 1 i = 1 i=1），现存所有元素（共 n n n 个）都需后移，时间复杂度为 O ( n ) O(n) O(n)。
    • 动态数组：在表头插入且空间不够，需先执行扩容操作，移动表内现存的所有元素，共 n n n 次。然后再插入新的元素，将表内的旧元素全部后移一位，共 n n n 次。总共需要 2 n 2n 2n 次移动，时间复杂度为 O ( n ) O(n) O(n)。
  • 平均情况：令 p i p_i pi​ 为在第 i i i 个位置上插入一个元素的概率，假设任意一个位置上发生插入元素的概率是相等的，那么 p i = 1 ( n + 1 ) p_i = \frac{1}{(n+1)} pi​=(n+1)1​。在长度为 n n n 的线性表中插入一个元素时，所需移动元素的平均次数为
    ∑ i = 1 n + 1 p i ( n − i + 1 ) = n 2 \sum_{i=1}^{n+1} p_i(n-i+1) = \frac{n}{2} i=1∑n+1​pi​(n−i+1)=2n​
    因此，平均情况的时间复杂度为 O ( n ) O(n) O(n)。

2.2.2 删除操作

删除顺序表 L L L 中第 i ( 1 ≤ i ≤ L . l e n g t h + 1 ) i(1 \le i \le L.\mathrm{length+1}) i(1≤i≤L.length+1) 个位置的元素，用引用变量 e e e 返回。若 i i i 的值不合法，则返回 false ；否则，将被删除元素赋给引用变量 e e e ，并将第 i = 1 i=1 i=1 个元素及其后的所有元素依次往前移动一个位置，返回 true 。

/*** 动态数组顺序表实现删除操作 ***/
// 删除操作
bool listDelete(SqList &L, int i, elemType &e){
    if (i<1 || i>L.length){                    // 判断i的范围是否有效
        printf("Index is illegal!\n");
        return false;
    }
    e = L.data[i-1];                          // 将被删除的元素的值赋给e
    for (int j=i;j<L.length;j++){              // 将位置i以后的元素向前移动一位
        L.data[j-1] = L.data[j];
    }
    L.length--;
    return true;
}

时间复杂度分析

分析和插入操作类似，删除操作的基本操作也是对元素的移动。

  • 最优情况：在表尾删除（即 i = n i = n i=n），元素不用后移，时间复杂度为 O ( 1 ) O(1) O(1)。
  • 最差情况：在表头删除（即 i = 1 i = 1 i=1），现存所有元素（共 n n n 个）都需前移，时间复杂度为 O ( n ) O(n) O(n)。
  • 平均情况：令 p i p_i pi​ 为在第 i i i 个位置上删除一个元素的概率，假设任意一个位置上发生插入元素的概率是相等的，那么 p i = 1 n p_i = \frac{1}{n} pi​=n1​。在长度为 n n n 的线性表中插入一个元素时，所需移动元素的平均次数为
    ∑ i = 1 n p i ( n − i ) = n − 1 2 \sum_{i=1}^{n} p_i(n-i) = \frac{n-1}{2} i=1∑n​pi​(n−i)=2n−1​
    因此，平均情况的时间复杂度为 O ( n ) O(n) O(n)。

2.2.3 按值查找操作

在顺序表 L L L 中查找第一个元素值等于 e e e 的元素，并返回其位序。

/*** 动态数组顺序表实现按位查找操作 ***/
// 按值查找操作
int locateElem(SqList L, elemType e){
    for (int i=0;i<L.length;i++){
        if (L.data[i] == e){
            return i+1;
        }
    }
    return 0;
}

时间复杂度分析
查找操作的基本操作是比较元素，因此我们只关注元素的比较次数。

  • 最优情况：查找元素就在表头（即 i = 1 i = 1 i=1），只用比较一次，时间复杂度为 O ( 1 ) O(1) O(1)。
  • 最差情况：查找元素在表尾（即 i = n i = n i=n）或不存在时，需要比较表内的所有元素，共 n n n 次，时间复杂度为 O ( n ) O(n) O(n)。
  • 平均情况：令 p i p_i pi​ 为查找元素出现在第 i i i 个位置上的概率，假设任意一个位置上发生插入元素的概率是相等的，那么 p i = 1 n p_i = \frac{1}{n} pi​=n1​。在长度为 n n n 的线性表中插入一个元素时，所需移动元素的平均次数为
    ∑ i = 1 n p i × i = ∑ i = 1 n 1 n × i = 1 n n ( n + 1 ) 2 = n + 1 2 \sum_{i=1}^{n} p_i \times i = \sum_{i=1}^{n}\frac{1}{n}\times i = \frac{1}{n} \frac{n(n+1)}{2} = \frac{n+1}{2} i=1∑n​pi​×i=i=1∑n​n1​×i=n1​2n(n+1)​=2n+1​
    因此，平均情况的时间复杂度为 O ( n ) O(n) O(n)。

参考资料：
【C++】细说C++中的数组之“静态”数组
【C++】细说C++中的数组之动态数组

相关章节

第一节 【绪论】数据结构的基本概念
第二节 【绪论】算法和算法评价
第三节 【线性表】线性表概述
第四节 【线性表】线性表的顺序表示和实现
第五节 【线性表】线性表的链式表示和实现
第六节 【线性表】双向链表、循环链表和静态链表
第七节 【栈和队列】栈
第八节 【栈和队列】栈的应用
第九节 【栈和队列】栈和递归
第十节 【栈和队列】队列


附录

静态数组实现顺序表的完整代码

/*
 * File: SqList.h
 * -------------------------
 * Using struct to implement SqList
 */

/********** 使用静态数组实现顺序表 **********/
#ifndef _STATIC_SEQUENTIAL_LIST_h_
#define _STATIC_SEQUENTIAL_LIST_h_

#include <stdio.h>
#include <iostream>
using namespace std;


/*** 静态数组顺序表的定义 ***/
#define MaxSize 10              // 默认静态数组最大容量为10

typedef int elemType;           // 定义新的类型elemType
typedef struct {
    elemType data[MaxSize];
    int length;                 // 记录静态数组的有效长度
} SqList;


/*** 基本操作的实现 ***/
// 初始化操作
void initList(SqList &L){
    L.length = 0;              // 将有效长度归零
}

// 销毁操作
void destroyList(SqList &L){}

// 判空操作
bool listEmpty(SqList L){
    return not L.length;
}

// 求表长操作
int listLength(SqList L){
    return L.length;
}

// 按位查找操作，如果存在返回1，否则返回0
int getElem(SqList L, int i, elemType &e){
    if (i<1 || i>L.length) {
        printf("Index is illegal!\n");
        return 0;
    } else {
        e = L.data[i-1];
        return 1;
    }
}


// 按值查找操作，返回第一个符合查找要求的元素的位置，如果不存在则返回0
int locateElem(SqList L, elemType e){
    for (int i=0;i<L.length;i++){
        if (L.data[i] == e){
            return i+1;
        }
    }
    return 0;
}

// 插入操作，在位值i处插入元素e
bool listInsert(SqList &L, int i, elemType e){
    if (i<1 || i>L.length+1){          // 判断i的范围是否有效
        printf("Index is illegal!\n");
        return false;
    }   
    if (L.length >= MaxSize){          // 判断存储空间是否还有剩余
        printf("Out of space!\n");
        return false;
    }
    for (int j=L.length;j>=i;j--){     // 将位置i及之后的元素向后移动一位
        L.data[j] = L.data[j-1];
    }
    L.data[i-1] = e;
    L.length++;
    return true;
}

// 删除操作，删除第i个位置的元素，并用e返回删除元素的值
bool listDelete(SqList &L, int i, elemType &e){
    if (i<1 || i>L.length){            // 判断i的范围是否有效
        printf("Index is illegal!\n");
        return false;
    }
    e = L.data[i-1];                   // 将被删除的元素的值赋给e
    for (int j=i;j<L.length;j++){      // 将位置i以后的元素向前移动一位
        L.data[j-1] = L.data[j];
    }
    L.length--;
    return true;
}

// 输出操作
void listPrint(SqList L){
    for (int i=0;i<L.length;i++){
        printf("%d ", L.data[i]);
    }
    printf("\n");
}


#endif // _STATIC_SEQUENTIAL_LIST_h_

动态数组实现顺序表的完整代码

/*
 * File: SqList.h
 * -------------------------
 * Using struct to implement SqList
 */

/********** 使用动态数组实现顺序表 **********/
#ifndef _DYNAMIC_SEQUENTIAL_LIST_h_
#define _DYNAMIC_SEQUENTIAL_LIST_h_

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;


/***** 动态数组顺序表的定义 *****/
#define InitSize 10         // 动态数组初始容量为10
#define Increment 10        // 线性表存储空间的分配增量

typedef int elemType;       // 定义新的类型elemType
typedef struct {
    elemType *data;
    int capacity, length;   // 动态数组当前最大容量和有效长度
} SqList;


/***** 基本操作的实现 *****/
// 初始化操作
void initList(SqList &L){
    L.data = new elemType[InitSize]; // 申请内存
    L.length = 0;
    L.capacity = InitSize;
}

// 销毁操作
void destroyList(SqList &L){
    if (L.data != NULL){
        delete[] L.data;
        L.length = 0;
        L.capacity = 0;
    }
}

// 判空操作
bool listEmpty(SqList L){
    return not L.length;
}

// 求表长操作
int listLength(SqList L){
    return L.length;
}

// 按位查找操作
int getElem(SqList L, int i, elemType &e){
    if (i<1 || i>L.length) {
        printf("Index is illegal!\n");
        return 0;
    } else {
        e = L.data[i-1];
        return 1;
    }
}

// 按值查找操作
int locateElem(SqList L, elemType e){
    for (int i=0;i<L.length;i++){
        if (L.data[i] == e){
            return i+1;
        }
    }
    return 0;
}

// 扩容操作
void increment(SqList &L){
    elemType *data = new elemType[L.capacity+Increment];   // 重新申请内存
    for (int i=0;i<L.capacity;i++){                        // 将原来的元素移动到新的顺序表中
        data[i] = L.data[i];
    }
    delete[] L.data;                                       // 释放内存
    L.data = data;
    L.capacity += Increment;
    printf("Finish Increment.\n");
}

// 插入操作
bool listInsert(SqList &L, int i, elemType e){
    if (i<1 || i>L.length+1){               // 判断i的范围是否有效
        printf("Index is illegal!\n");
        return false;
    }   
    if (L.length >= L.capacity){            // 判断存储空间是否还有剩余,
        printf("Need Increment.\n");
        increment(L);                       // 不够则扩容
    }
    for (int j=L.length;j>=i;j--){          // 将位置i及之后的元素向后移动一位
        L.data[j] = L.data[j-1];
    }
    L.data[i-1] = e;
    L.length++;
    return true;
}

// 删除操作
bool listDelete(SqList &L, int i, elemType &e){
    if (i<1 || i>L.length){                    // 判断i的范围是否有效
        printf("Index is illegal!\n");
        return false;
    }
    e = L.data[i-1];                          // 将被删除的元素的值赋给e
    for (int j=i;j<L.length;j++){             // 将位置i以后的元素向前移动一位
        L.data[j-1] = L.data[j];
    }
    L.length--;
    return true;
}

// 输出操作
void listPrint(SqList L){
    for (int i=0;i<L.length;i++){
        printf("%d ", L.data[i]);
    }
    printf("\n");
}


#endif // _DYNAMIC_SEQUENTIAL_LIST_h_

顺序表检测程序

/*
 * File name: SqList.cpp
 * -----------------------
 * Using struct to implement SqList
 */

#include "SqList.h"

int main(){
    SqList L;
    initList(L);
    
    int n, i, res;
    elemType e;

    char helpInfo[] = "*****************************\n" \
                        "Sequential list check: \n"                     
                        "\t1-Insert element\n" \
                        "\t2-Delete element\n" \
                        "\t3-Print\n" \
                        "\t4-Empty check\n" \
                        "\t5-Get Length\n" \
                        "\t6-Search by value\n" \
                        "\t7-Search by location\n" \
                        "\t8-Initialization\n" \
                        "\t9-Quit\n" \
                        "*****************************\n";                  

    while (n!= 9){
        printf(helpInfo);
        scanf("%d", &n);
        switch(n){
            case 1:
                printf("Please enter the location: ");
                scanf("%d", &i);
                printf("Please enter the element: ");
                scanf("%d", &e);
                listInsert(L, i, e);
                break;
            case 2:
                printf("Please enter the location: ");
                scanf("%d", &i);
                listDelete(L, i, e);
                printf("Element in location %d with value %d has been deleted.\n", i, e);
                break;
            case 3:
                printf("List: ");
                listPrint(L);
                break;
            case 4:
                if (listEmpty(L)) {
                    printf("This list is empty!\n");
                }else {
                    printf("This list is not empty!\n");
                }
                break;
            case 5:
                printf("Length of list is: %d\n", listLength(L));
                break;
            case 6:
                printf("Please enter the target value: ");
                scanf("%d", &e);
                res = locateElem(L, e);
                if (res) {
                    printf("The index of target is %d\n", res);
                } else {
                    printf("We didn't find the value.\n");
                }
                break;
            case 7:
                printf("Please enter the target index: ");
                scanf("%d", &i);
                res = getElem(L, i, e);
                if (res) {
                    printf("The value of target is %d\n", e);
                }
                break;
            case 8:
                initList(L);
                printf("List has been initialized.\n");
                break;
        }
    }
    
    destroyList(L);
    return 0;
}
Fu Junzhe
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表的顺序表示和实现
m0_62670778的博客
09-13 1099
ADT List{数据对象：D={ai|ai∈Elemset,i=1,2,…,n,n≥0}数据关系：R={|ai-1,ai∈D,i=2,…,n}#define MAXSIZE 10000 //图书表可能达到的最大长度typedef struct //图书信息定义{//图书ISBN//图书名字//图书价格}Book;{//存储空间的基地址//图书表中当前图书个数}SqList;//图书表的顺序存储结构类型为SqList。
算法与数据结构 --- 线性表 --- 顺序表示和实现
最新发布
qq_51947882的博客
09-13 1036
list是线性表的英文名字，Elemset1. initialization 初始化2.销毁线性表的本质是将线性表从内存中删除3.置为空表的意思是将线性表中的元素全都删除1.数据元素判断函数的返回值类型是bool类型，当函数返回一个 true 时表示函数满足，返回一个false 时表示函数不满足2.这个函数会将我们传进来的 e 作为左参数，同时将 线性表中的每个元素依次作为右参数，左右参数进行比较，右参数依次变换，直到返回true为止，若比完了最后一个元素后仍无true则结束。
数据结构教程 第六课 线性表的顺序表示和实现
kong0613的专栏
05-25 782
本课主题： 栈的表示与实现 教学目的： 栈的数据类型定义、栈的顺序存储表示与实现 教学重点： 栈的顺序存储表示与实现方法 教学难点： 栈的定义 授课内容： 一、栈的定义 栈是限定仅在表尾进行插入或删除操作的线性表。 栈的表尾称为栈顶，表头称为栈底，不含元素的空表称为空栈。 栈的抽象数据类型定义： ADT Stack{ 数据对象:D
线性表的顺序表示及实现
我的梦
10-31 1200
经过一个星期的学习,主要学习鲍春山的视频教程和严蔚敏的数据结构，将线性表的学习记录下来，和大家分享。如有错误，不吝指正！ —-2017.10
C语言线性表的顺序表示与实现实例详解
09-04
总之，C语言中的线性表顺序表示是一种基础且实用的数据结构，适用于各种算法和应用，但需要根据具体需求权衡其优势和限制。在实际编程中，根据数据的特性选择合适的数据结构是优化算法性能的关键。
数据结构之线性表的顺序表示和实现
05-28
以上就是关于“数据结构之线性表的顺序表示和实现”的主要知识点，以及可能的代码实现结构。通过这三个文件，我们可以学习如何在C++中实现一个基本的顺序表，并对其进行操作。这不仅有助于理解数据结构的基础，也为...
线性表的顺序存储与实现
07-29
线性表是计算机科学中一种基础的数据结构，它是由n（n≥0）个相同...提供的文件"02-线性表的顺序存储与实现"很可能是关于如何在具体编程语言中实现这些操作的示例代码，可以作为学习和理解线性表顺序存储的参考资料。
数据结构_线性表的顺序表示与实现
09-06
文件“数据结构_线性表的顺序表示与实现”很可能会详细讲解这些概念，并通过示例代码演示如何在程序中实现上述操作。学习这部分内容对于理解数据结构和算法的基础至关重要，有助于提升编程能力，特别是在处理大量...
JS实现线性表的顺序表示方法示例【经典数据结构】
10-20
本篇将重点讨论JS实现的线性表顺序表示方法。 顺序表示是指将线性表的数据元素存储在一块连续的内存空间中，每个元素的存储位置与其在表中的位置成正比。这种方式通常使用数组来实现，因为数组的特性就是通过索引...
线性表的顺序实现
03-13
此代码主要是线性表的顺序实现，操作者先分析代码，在进行相应的操作。
线性表顺序表示及实现源码
11-11
线性表的顺序表示和实现源码。 Blog: http://blog.csdn.net/algorithm_only
线性表的顺序表示 （go语言实现）
qq_40393865的博客
03-09 339
概念 线性表的顺序表示指的是用一组地址连续的储存单元依次储存线性表的数据元素，这种表示也称作线性表的顺序存储结构或顺序。通常，称这种存储结构的线性为顺序表。特点，逻辑上相邻的数据元素，其物理性质也相邻的。 每一元素的储存位置都和线性表的起始位置相差一个常数，这个常数和数据元素在线性表中的位序成正比。由此，只要确定了存储线性表的起始位置，线性表的任一元素都可随机存取，所以线性表的顺序存储结构是一种随...
6.线性表的顺序实现
YZSS17的博客
12-04 169
线性表的存储结构 在计算机中线性表有两种存储结构分别是顺序存储结构和链式存储结构。 线性表的顺序表示(又称顺序存储结构或顺序映象) 顺序存储定义:把逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构。 线性表的顺序存储结构是指用一段地址连续的存储单元依次存储线性表的数据元素。 例如:线性表(1,2,3,4,5,6) 线性表的第1个数据元素a1的存储位置称为线性表的起始位置或基地址. 顺序存储结构的寻址公式 计算地址只算一次与处理数据的规模无关数量级是O(1)这种运算叫随机存取。
实验1 线性表的顺序实现
热门推荐
wlxsq的专栏
12-22 2万+
实验目录 基于sequlist.h中定义的顺序表，编写算法函数reverse(sequence_list *L)，实现顺序表的就地倒置。编写一个算法函数void sprit( sequence_list *L1,sequence_list *L2,sequence_list *L3)，将顺序表L1中的数据进行分类，奇数存放到存到顺序表L2中，偶数存到顺序表L3中，编写main()
线性表详解：顺序与链式表示
非空线性表通常表示为(a1, a2, ..., an)，其中每个元素ai都有一个唯一的直接前驱ai-1（对于i > 1）和一个直接后继ai+1（对于i ）。线性表的这种一对一的关系使得数据元素形成一个有序的序列。 在逻辑结构上，线性表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值