线性顺序表

最新推荐文章于 2024-11-09 20:55:32 发布
原创 最新推荐文章于 2024-11-09 20:55:32 发布 · 1.2k 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
数据结构

当前文章被收录于：

数据结构
11 篇文章 3 人学习
订阅专栏 查看详情

线性表：

简介：

线性表是最基本、最简单、也是最常用的一种数据结构。

线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储），但是把最后一个数据元素的尾指针指向了首位结点）。

我们说“线性”和“非线性”，只在逻辑层次上讨论，而不考虑存储层次，所以双向链表和循环链表依旧是线性表。

在数据结构逻辑层次上细分，线性表可分为一般线性表和受限线性表。一般线性表也就是我们通常所说的“线性表”，可以自由的删除或添加结点。受限线性表主要包括栈和队列，受限表示对结点的操作受限制。

线性表的逻辑结构简单，便于实现和操作。因此，线性表这种数据结构在实际应用中是广泛采用的一种数据结构。

定义：

线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。数据元素是一个抽象的符号，其具体含义在不同的情况下一般不同。

在稍复杂的线性表中，一个数据元素可由多个数据项（item）组成，此种情况下常把数据元素称为记录（record），含有大量记录的线性表又称文件（file）。

线性表中的个数n定义为线性表的长度，n=0时称为空表。在非空表中每个数据元素都有一个确定的位置，如用ai表示数据元素，则i称为数据元素ai在线性表中的位序。

线性表的相邻元素之间存在着序偶关系。如用（a1，…，ai-1，ai，ai+1，…，an）表示一个顺序表，则表中ai-1领先于ai，ai领先于ai+1，称ai-1是ai的直接前驱元素，ai+1是ai的直接后继元素。当i=1,2，…，n-1时，ai有且仅有一个直接后继，当i=2，3，…，n时，ai有且仅有一个直接前驱。

特征：

  1. 集合中必存在唯一的一个“第一元素”。
  2. 集合中必存在唯一的一个 “最后元素” 。
  3. 除最后一个元素之外，均有 唯一的后继(后件)。
  4. 除第一个元素之外，均有 唯一的前驱(前件)。

基本操作：

  1. MakeEmpty(L) 这是一个将L变为空表的方法

  2. Length（L） 返回表L的长度，即表中元素个数

  3. Get（L，i） 这是一个函数，函数值为L中位置i处的元素（1≤i≤n）

  4. Prior（L，i） 取i的前驱元素

  5. Next（L，i） 取i的后继元素

  6. Locate（L，x） 这是一个函数，函数值为元素x在L中的位置

  7. Insert（L，i，x）在表L的位置i处插入元素x，将原占据位置i的元素及后面的元素都向后推一个位置

  8. Delete（L，p） 从表L中删除位置p处的元素

  9. IsEmpty(L) 如果表L为空表(长度为0)则返回true，否则返回false

  10. Clear（L）清除所有元素

  11. Init（L）同第一个，初始化线性表为空

  12. Traverse（L）遍历输出所有元素

  13. Find（L，x）查找并返回元素

  14. Update（L，x）修改元素

  15. Sort（L）对所有元素重新按给定的条件排序

  16. strstr(string1,string2)用于字符数组的求string1中出现string2的首地址

顺序表的定义：

顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构是顺序结构。

顺序表的表示与实现：

base.h：

这个头文件主要用来存放公用的常量和类型。

//base.h
//-----公用的常量和类型----------
#include<iostream>
#include<stdlib.h>
#include<time.h>
using namespace std;
#include<malloc.h>
#include<string.h>

//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1 //不可行的 infeaslble
#define OVERFLOW -2

typedef int Status;
typedef int ElemType;

sqList.h：

aqList.h头文件用来具体实体实现各函数。

//sqList.h
//线性表存储空间的初始化分配量，为100
#define LIST_INIT_SIZE 100
//线性表存储空间的分配增量 10
#define LISTINCREMENT 10

typedef struct{
    ElemType * elem; //存放空间基址
    int length;   //当前长度
    int listsize; //当前分配的存储容量
}SqList;

//构造一个空的线性表
Status InitList_Sq(SqList &L){
    //构造一个空的线性表L
    L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    if(!L.elem) exit(OVERFLOW);  //如果存储分配失败，退出
    L.length = 0;  //空白长度为0
    L.listsize = LIST_INIT_SIZE;  //初始存储容量
    return OK;
}//InitList_Sq

//销毁列表L
Status DestroyList(SqList &L){
    if(L.elem){
        free(L.elem);
        L.elem = NULL;
        cout<<"线性表销毁成功！"<<endl;
        return OK;
    }else{
        cout<<"线性表不存在,不需要销毁！"<<endl;
        return ERROR;
    }
}//DestroyList

//初始条件：线性表L已存在
//操作结果：将L置为空表
Status ClearList_Sq(SqList &L){
    L.length = 0;
    cout<<"线性表清空成功！"<<endl;
    return OK;
}//ClearList_Sq

//初始条件：线性表L已存在
//操作结果：若为空表返回TRUE，不为空返回FALSE
Status ListIsEmpty_Sq(SqList L){
    if(L.length == 0) //如果列表长度为0，返回TRUE
        return TRUE;
    else    //否则返回FALSE
        return FALSE;

}// ListIsEmpty_Sq

//初始条件：线性表L已存在
//操作结果：返回线性表中元素的个数
Status ListLength_Sq(SqList L){
    return L.length;
}//ListLength

//初始条件：线性表L已存在
//操作结果：获得列表第i个值
Status GetElem_Sq(SqList L, int i, ElemType &e){
    if(L.length == 0 || i < 1 || i > L.length)
        return ERROR;
    e = L.elem[i-1];
    return OK;
}//GetElem_Sq

//初始条件：线性表L已存在
//操作：查找其中某个值，返回L中第一个与e相等的数据元素的位序
//      若没找到返回0
Status LocateElem_Sq(SqList L, ElemType e){
     int i = 1;
     ElemType *p = L.elem;
     while(i <= L.length && *p++ != e)
        ++i;
     if(i < L.length)
        return i;
     else
        return 0;
}//LocateElem_Sq

//初始条件：线性表L已存在
//操作：获得前驱
Status PriorElem_Sq(SqList L, ElemType cur_e, ElemType pre_e){
    int i=0;
    while(i < L.length && !(L.elem[i] == cur_e))
        ++i;
    if(i == 0 || i == L.length){
        cout<<cur_e<<"没有前驱！"<<endl;
        return ERROR;
    }else{
        pre_e = L.elem[i-1];
        cout<<cur_e<<"的前驱是："<<pre_e<<endl;
        return OK;
    }
}//PriorElem_Sq

//初始条件：线性表L已存在
//操作：求后继
Status NextElem_Sq(SqList L, ElemType cur_e, ElemType next_e){
    int i=0;
    while(i < L.length && !(L.elem[i] == cur_e))
        ++i;
    if(i >= L.length - 1){
        cout<<cur_e<<"没有后继！"<<endl;
        return ERROR;
    }else{
        next_e = L.elem[i+1];
        cout<<cur_e<<"的后继是："<<next_e<<endl;
        return OK;
    }
}//NextElem_Sq

//初始条件：线性表L已存在
//操作，插入一个元素
Status ListInsert_Sq(SqList &L, int i, ElemType e){
    //在顺序线性表L中第i个位置之前插入新的元素e
    //i的合法值为 1<= i <=ListLength_Sq(L) + 1;
    if(i < 1 || i > L.length+1)
        return ERROR; //如果i的值不合法，返回错误
    if(L.length >= L.listsize){
        ElemType *newbase;
        newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
        if(!newbase) //如果空间分配失败，返回溢出
            return OVERFLOW;
        L.elem = newbase; //把分配的新地址给列表
        L.listsize += LISTINCREMENT; //增加存储容量
    }
    ElemType *q, *p;
    q = &(L.elem[i-1]); //q为插入的位置
    for(p = &(L.elem[L.length - 1]); p >= q; --p)
        *(p + 1) = *p; //插入位置之后的元素右移
    *q = e; //插入e
    ++L.length; //列表长度加1
    return OK;
}//ListInsert_Sq

//初始条件：线性表L已存在
//操作：删除某个元素
Status ListDelete_Sq(SqList &L, int i, ElemType &e){
    //在顺序线性表中删除第i个元素，并用e返回其值
    //i的合法值为 1<= i <= L.length_Sq(L)
    if(i < 1 || i > L.length) return ERROR;
    ElemType *p = &(L.elem[i-1]);//p为删除元素的位置
    e = *p;  //被删除元素的值赋给e
    ElemType *q = L.elem + L.length - 1; //q为列表尾元素地址
    for(++p; p <= q; ++p)
        *(p-1) = *p;  //被删除元素之后的位置左移
    --L.length; //表常减1
    return OK;
}//ListDelete_Sq

//初始条件：线性表L已存在
//操作：修改表中元素
Status Update_Sq(SqList L, ElemType cur_e, ElemType new_e){
    if(LocateElem_Sq(L,cur_e) != 0)
    {
        L.elem[LocateElem_Sq(L,cur_e)-1] = new_e;
        cout<<"元素更新成功！"<<endl;
        return OK;
    }else{
        cout<<"本列表中没有 "<<cur_e<<"元素，无法更新数据！"<<endl;
        return ERROR;
    }
}//Update_Sq

//遍历列表
Status ListTraverse(SqList &L){
    if(L.length == 0)
        cout<<"列表为空表！"<<endl;
    else{
        for(int i = 1; i <= L.length; i++){
            if(i == L.length) //如果为最后一个数，最后输出换行符
                cout<<L.elem[i-1]<<endl;
            else
                cout<<L.elem[i-1]<<" , ";
        }
    }
    return OK;
}//LisetTraverse

main.cpp：

用来测试上面的函数。

#include "base.h"
#include "sqList.h"

int main(){
    SqList L;
    int i;
    ElemType e;
    InitList_Sq(L); //初始化线性表
    cout<<"遍历表：";
    ListTraverse(L); //遍历表
    //给表赋值
    for(i = 0; i < 10; i++)
        ListInsert_Sq(L,1,i);
    cout<<"列表是否为空："<<ListIsEmpty_Sq(L)<<endl;
    cout<<"在给列表赋值十个值后的遍历表：";
    ListTraverse(L); //遍历表
    cout<<"列表的长度是："<<ListLength_Sq(L)<<endl;
    ListInsert_Sq(L,5,500); //在第五个位置插入500
    cout<<"第五个位置插入500后的遍历表：";
    ListTraverse(L);
    ListDelete_Sq(L,5,e);
    cout<<"删除操作，删除的数是："<<e<<endl;
    cout<<"删除第五个位置的元素后的遍历表：";
    ListTraverse(L);
    GetElem_Sq(L,5,e);
    cout<<"获取第五个位置的数："<<e<<endl;
    cout<<"与1相等的是第："<<LocateElem_Sq(L,1)<<"位"<<endl;
    cout<<"把8改为3操作：";
    Update_Sq(L,8,3);
    cout<<"更新元素后的遍历表：";
    ListTraverse(L);
    PriorElem_Sq(L,5,e);
    PriorElem_Sq(L,9,e);
    NextElem_Sq(L,5,e);
    NextElem_Sq(L,0,e);
    cout<<"清空线性表：";
    ClearList_Sq(L);
    cout<<"列表是否为空："<<ListIsEmpty_Sq(L)<<endl;
    DestroyList(L); //第一次销毁线性表
    DestroyList(L);//第二次销毁线性表

    return 0;
}

主方法测试结果：

这里写图片描述

图：程序测试结果

标签
#数据结构 #线性表
C语言-B树（B-树）的完整实现
geek_jerome的博客
12-25 2万+
B树的定义 B树是一种平衡的多路查找树。 一颗m阶B树，或为空树，或为满足下列特性的m叉树。 （1）树中每个结点最多含有m棵子树; （2）若根结点不是叶子结点，则至少有两颗子树; （3）除根之外的所有非终端结点至少有[m/2]; （4）每个非终端结点中包含信息：（n,A0,K1,A1,K2,A2,…,Kn,An)。其中 ①Ki（1≤i≤n）为关键字，且关键字按升序排序。 ②指针Ai（
数据结构_顺序表
qq_44040736的博客
10-30 698
一.顺序表的基本操作 ​ 声明： 以下算法操作均为C语言执行，代码均参考老师上课所讲内容 ​ //--------------线性表的动态分配顺序存储结构--------------------// /*c2-1.h*/ #define SIZE 10 #define LIStINCREMENT 2 typedef struct{ ElemType *elem; int...
线性表的链式实现（数据结构-严蔚敏）
02-03
刚学了数据结构，根据书上的每个ADT操作都谢了代码，测试通过~ 可以说很详细了！ int InitList(LinkList &L) int DestroyList(LinkList &L) int ClearList(LinkList &L) int ListEmpty(LinkList L) int ListLength(LinkList L) int GetElem(LinkList L, int i, int &e) int Compare(int a, int b) int LocateElem(LinkList L, int e, int i, int Compare(int ,int)) int PriorElem(LinkList L, int cur_e, int &pre_e) int NextElem(LinkList L, int cur_e, int &next_e) int ListInsert(LinkList &L, int i, int e) int ListDelete(LinkList &L, int i, int &e) int Visit(LinkList L) int ListTraverse(LinkList L) 线性表的链式实现（数据结构-严蔚敏）线性表的链式实现（数据结构-严蔚敏）线性表的链式实现（数据结构-严蔚敏）线性表的链式实现（数据结构-严蔚敏）线性表的链式实现（数据结构-严蔚敏）线性表的链式实现（数据结构-严蔚敏）线性表的链式实现（数据结构-严蔚敏）线性表的链式实现（数据结构-严蔚敏）线性表的链式实现（数据结构-严蔚敏）线性表的链式实现（数据结构-严蔚敏）线性表的链式实现（数据结构-严蔚敏）
数据结构之线性表（List）（一）
semu2000的博客
04-05 862
线性表是具有相同类型的n(n >= 0)个数据元素的有限序列，其中n为表长，当n=0时，线性表为空表。若用L命名线性表，则一般表示为：L=（a1，a2，...ai，ai+1，...，an）。其中，a1是唯一的“第一个”数据元素，又称为表头元素；an是唯一的“最后一个元素”，又称为表尾元素。除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继。以上为线性表的逻辑特性。线性表的顺序存储又称顺序表。
LocateElem()&ListTraverse;()实例说明
10-31
LocateElem(L,e,compare())&ListTraverse;(L,visit())实例说明
List：：traverse遍历
热门推荐
ganxiang2011的博客
05-28 1万+
声明：// 遍历 void traverse(void (*)(T&)); //遍历，依次实施visit操作（函数指针，只读或局部性修改） template <typename VST> //操作器 void traverse(VST&); //遍历，依次实施visit操作（函数对象，可全局性修改）定义：template <typename T> void List<T>::tra
线性表之顺序表
qq_45630711的博客
12-28 2477
import java.util.Arrays; public class MyArraylist { int[] element;//数组 int size;//线性表实际大小 public MyArraylist() { this.size=0; this.element=new int[4]; } public MyArraylist(int capacity) { this.size=0; thi
线性表和顺序表
Ll_R_lL的博客
04-25 2708
1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构 常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。 但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 2.顺序表 2.1概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。（要求：数据必须从第一个位置开始，
【数据结构】线性表——顺序表
Bucai_不才的博客
11-07 2419
详细讲解了线性表是什么、顺序表是什么，如何实现，深入浅出。
【数据结构与算法】线性表、顺序表、静态顺序表、动态顺序表
DreamSuif的博客
04-05 1137
本篇文章大部分内容摘自严蔚敏、李冬梅、吴伟民编著的由人民邮电出版社出版发行的《数据结构：C语言版》。本文中的所有代码使用C23标准的C语言实现，因此在编译时请加上-std=c2x，代码中若存在错误，欢迎大家在评论区指出。😘❤️❤️❤️线性表是最基本且最常用的一种线性结构，同时也是其他数据结构的基础，尤其是单链表，是贯穿整个数据结构课程的基本技术。在日常生活中，线性表的例子比比皆是。例如，26个英文字母(A,B,C, …, Z)、学生成绩表等。
线性表·顺序表
qq_54502707的博客
06-01 975
线性表是最常用且最简单的一种数据结构。一个线性表是n个数据元素的有限序列。在稍复杂的线性表中，一个数据元素可以由若干个数据项组成。在这种情况下，常把数据元素称为记录，含有大量记录的线性表you ...
线性表——顺序表
最新发布
daily_233的博客
11-09 954
线性表——顺序表的学习与模拟实现
线性表 —— 顺序表
starter_____的博客
05-09 2328
定义 线性表是具有相同特征数据元素的一个有限序列。该序列中所含元素的个数叫作线性表的长度，用 n 表示，当 n = 0 时，表示线性表是一个空表。 线性表可以是有序的，也可以是无序的 线性表的存储结构有顺序存储结构和链式存储结构两种。前者称为顺序表，后者称为链表。 顺序表就是把线性表中的所有元素按照其逻辑顺序，依次存储到从指定的存储位置开始的一块连续的存储空间中。 在链表存储中，每个结点不仅包...
【初阶数据与算法】线性表之顺序表的定义与实现
hdxbufcbjuhg的博客
11-03 8771
其中memmove的第一个参数是我们要移动的目标位置的地址，很明显就是顺序表中第二个元素的地址，即ps->arr+1，第二个参数就是我们源位置的地址，是顺序表中第一个元素的地址，即ps->arr，它的第三个参数就是要拷贝的字节数，就是有效元素个数乘以一个元素的大小。在上面静态顺序表的静态是指它的大小是固定的，同理，动态顺序表里面的动态就是指顺序表的大小是不固定的，也就是顺序表底层的数组的大小是不固定的，可以动态的变化，比如开始时给出4个元素的大小，不够时顺序表可以实现自动增容。
线性表与顺序表
withu
03-29 1224
线性表 线性表是n个具有相同属性的有限数列，常见的线性表有：顺序表，链表，栈，队列，字符串… 线性表在逻辑上是线性结构，也就是说连成一条直线，但是在物理结构上不一定连续，线性表在物理上存储是，通常以数组和链式结构的形式进行存储。 值得注意的是： 线性表示一个序列 0个元素构成的线性表是空表 线性表的第一个元素无前驱，最后一个元素无后继，其他元素只有一个前驱和后继 线性表是有长度的，其长度就是元素...
线性结构之顺序表
Lange_Taylor的博客
05-05 1107
什么是线性结构？ 线性结构是一个有序数据元素的集合. 线性结构中都包含什么内容？ 线性表，栈，队列，双队列，数组，串。 什么是顺序表？顺序表的分类？ 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组 上完成数据的增删查改。 顺序表一般可以分为： 1.静态顺序表：使用定长数组存储。 2.动态顺序表：使用动态开辟的数组存储。 用c语言来实现顺序表的基本操...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值