2021-12-18 数据结构——线性表(上) (c++代码和c代码)

已于 2022-05-02 22:19:42 修改
阅读量1.3k 收藏 8
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表 排序算法
于 2021-12-17 17:41:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011514176/article/details/121999173
版权

线性表是最基本、最简单、也是最常用的一种数据结构。==线性表（linear list)==是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。

1.基本概念

线性表：零个或多个数据元素的有限序列。
线性表：包括顺序表和链表
顺序表（数组）：里面元素的地址是连续的，
链表：链表里面节点的地址不是连续的，是通过指针连起来的。
表中元素个数称为线性表的长度
线性表没有元素时，称为空表
表起始位置称为表头，表结束位置称表尾

2. 线性表的抽象数据类型

类型名称：线性表（List）
操作集：线性表 L ∈ List，整数 i 表示位置，元素 X ∈ ElementType
线性表基本操作主要有：
c格式

线性表基本操作主要有：
List MakeEmpty()： 初始化一个空线性表 L
ElementType FindKth(int K,List L)：根据位序 K，返回相应元素
int Find(ElementType X,List L)：在线性表 L 中查找 X 的第一次出现位置
void Insert(ElementType X,int i,List L)：在位序 i 前插入一个新元素 X
void Delete(int i,List L)：删除指定位序 i 的元素
int Length(List L)：返回线性表 L 的长度 n

c++格式
ADT 线性表(List)
Data
线性表的数据对象集合为{a1,a2,…,an},每个元素的类型均为DataType。其中，除了第一个元素a1外，每一个元素有且只有一个直接前驱元素，除最后一个元素an外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。

    InitList(*L):初始化操作，建立一个空的线性表。
    ListEmpty(L):若线性表为空，返回true，否则返回false。
    ClearList(*L):线性表清空。
    GetElem(L,i,*e):将线性表L中第i个位置元素返回给e。
    LocateElem(L,e):在线性表L中查找与给定值e相等的元素，如果查找成功,返回该元素在表中的序列号；否则，返回0表示失败。
    ListInsert(*L,i,e):在线性表的第i个位置插入元素e。
    ListDelete(*L,i,*e):删除线性表L中的第i个元素，并用e返回其值
    ListLength(L):返回线性表L的元素个数。
    PrintList(L):打印线性表

3. 线性表的顺序存储

注意：在这里插入图片描述

3.1 顺序存储的定义

顺序表就是用数组实现，事实上就是在内存中找个初始地址，然后通过占位的形式，把一定连续的内存空间给占了，然后把相同数据类型的数据元素依次放在这块空地中。
顺序存储的大小有两种方式：一是静态分配，二是动态扩展
在这里插入图片描述

3.2 实现方式

c++模板代码：

const int MaxSize = 100;
template <class DataType>  //主要用于c＋＋的重用性方面：template是模板的定义名称，<>号中class不是类的定义，而是相当于变量名前的类型名一样
class SeqList
{
public:
    SeqList(){length=0;}            //无参数构造方法
    SeqList(DataType a[],int n);    //有参数构造方法
    ~SeqList(){}                    //析构函数
    int Length(){return length;}    //线性表长度
    DataType Get(int i);            //按位查找
    int Locate(DataType x);         //按值查找
    void Insert(int i,DataType x);  //插入
    DataType Delete(int i);         //删除
    void PrintList();               //遍历
private:
    DataType data[MaxSize];         //顺序表使用数组实现
    int length;                     //存储顺序表的长度
};

c语言模板代码：

#include<stdio.h>
#include<malloc.h>
#define MAXSIZE 100  // MAXSIZE 定义为 Data 数组的大小
typedef int ElementType;  // ElementType 可定义为任意类型
typedef struct LNode *List; 
struct LNode{
   ElementType Data[MAXSIZE]; 
   int Last;  // Last 定义线性表的最后一个元素
};
List L;
//访问下标为 i 的元素：L->Data[i]
//线性表的长度：L->Last+1

List MakeEmpty(); //初始化顺序表 
int Find(ElementType X,List L); //查找 X 第一次出现的下标 
void Insert(ElementType X,int i,List L); //在下标为 i 的地方插入 X 
void Delete(int i,List L);   //删除下标为 i 的当前值 
ElementType FindKth(int K,List L);  //返回下标为 K 的当前值
int Length(List L);  //返回顺序表的长度

//表长
int Length(List L){
	return L->Last+1;
}

顺序表的封装需要三个属性：
1.存储空间的起始位置。数组data的存储位置就是线性表存储空间的存储位置
2.线性表的最大存储容量。数组长度MAXSIZE
3.线性表的当前长度。length

MAXSIZE和length二者区别：数组的长度与线性表的长度是不一样的。数组的长度是存放线性表的存储空间的总长度，一般初始化后不变。而线性表的当前长度是线性表中元素的个数，是会改变的。

下面我们将实现顺序表的各个功能：

3.2.1 初始化

创建一个长度为n的顺序表，需要将给定的数组元素作为线性表的数据元素传入顺序表中，并将传入的元素个数作为顺序表的长度。
  在这里插入图片描述
c++

template <class DataType>
SeqList<DataType>::SeqList(DataType a[],int n)
{
    if(n>MaxSize) throw "wrong parameter";
    for(int i=0;i<n;i++)
        data[i]=a[i];
    length=n;
}

c语言

struct LNode{
   ElementType Data[MAXSIZE]; 
   int Last;  // Last 定义线性表的最后一个元素
};
//初始化 
List MakeEmpty(){
    List L;
    L = (List)malloc(sizeof(struct LNode));
    L->Last = -1;
    return L;
}
//访问下标为 i 的元素：L->Data[i]
//线性表的长度：L->Last+1

3.2.2 按位查找

按位查找的时间复杂度为O(1) 。

template <class DataType>
DataType SeqList<DataType>::Get(int i)
{
    if(i<1 && i>length) throw "wrong Location";
    else return data[i-1];
}

// 按序查找
ElementType FindKth(int K,List L){
	if(K < 0 || L->Last < K){  //位置越界
        printf("L->Data[%d]不存在元素",K);
        return;
    }
    return L->Data[K];
}

3.2.2 按值查找

按值查找，需要对顺序表中的元素依次进行比较，时间复杂度为O(n) 。

template <class DataType>
int SeqList<DataType>::Locate(DataType x)
{
    for(int i=0;i<length;i++)
        if(data[i]==x) return i+1;
    return 0;
}

// 按值查找 
int Find(ElementType X,List L){
    int i=0;
    while(i <= L->Last && L->Data[i] != X)  
        i++;
    if(L->Last < i)  //如果没找到，返回 -1
        return -1; 
    else    // 找到后返回下标 
        return i;
}

3.2.3 插入

插入的过程中需要注意元素移动的方向，==必须从最后一个元素开始移动，如果表满了，则引发上溢；==如果插入位置不合理，则引发位置异常
  在这里插入图片描述

template <class DataType>
void SeqList<DataType>::Insert(int i,DataType x)  //i不是下标，是第几个元素
{
    if(length>=MaxSize) throw "Overflow";
    if(i<1 || i>length+1) throw "Location";  //排除两边插入
    for(int j=length;j>=i;j--)
        data[j]=data[j-1];
    data[i-1]=x;
    length++;
}

// 插入
void Insert(ElementType X,int i,List L){
    int j;
    if(L->Last == MAXSIZE-1){  //位置已满 
        printf("表满");
        return;
    }
    if(i < 0 || L->Last+1 < i){  //位置越界，如果将数插入 L->Data[L->Last+1]，下面都不用腾位置了 ，排除两边插入
        printf("位置不合法");
        return;
    }
    for(j=L->Last;j>=i;j--)   // 从后往前依次向后挪一个，给 a[i]腾出位置     
        L->Data[j+1] = L->Data[j];   
    L->Data[i] = X;    //新元素插入
    L->Last++;    // Last仍然指向最后元素
    return;
}

3.2.4 删除

注意算法中元素移动方向，移动元素之前必须取出被删的元素，如果表为空则发生下溢，如果删除位置不合理，则引发删除位置异常。
在这里插入图片描述

template <class DataType>
DataType SeqList<DataType>::Delete(int i)  //i是第几个元素
{
    int x;
    if(length==0) throw "Underflow";  //一个元素也没有
    if(i<1 || i>length) throw "Location"; //越界了
    x = data[i-1];
    for(int j=i;j<length;j++)
        data[j-1] = data[j];
    length--;
    return x;
}

//删除
void Delete(int i,List L){
    int j;
    if(i < 0 || L->Last <i){  //位置越界，而删除最多到 L->Data[L->Last]
        printf("L->Data[%d]不存在元素",i);
        return;
    }
    for(j=i;j<=L->Last;j++)   // 从前往后依次向前挪一个，将 a[i] 覆盖了 
        L->Data[j-1] = L->Data[j];
    L->Last--;  // Last仍然指向最后元素
    return;
}

3.2.5 遍历

按下标依次输出各元素

template <class DataType>
void SeqList<DataType>::PrintList()
{
    for(int i=0;i<length;i++)
        cout<<data[i]<<endl;
}

for(i=0;i<Length(L);i++)
		printf("%d ",L->Data[i]);

3.2.6 实战

int main()
{
    SeqList<int> p;
    p.Insert(1,5);
    p.Insert(2,9);
    p.PrintList();
    p.Insert(2,3);
    cout<<p.Length()<<endl;
    p.PrintList();
    cout<<p.Get(3)<<endl;
    p.Delete(2);
    p.PrintList();
    return 0;
}

int main(){
	int i=0;
	L = MakeEmpty();
	Insert(11,0,L);
	printf("在线性表L-Data[0]插入11\n");
	Insert(25,0,L);
	printf("在线性表L-Data[0]插入25\n");
	Insert(33,0,L);
	printf("在线性表L-Data[0]插入33\n");
	Insert(77,0,L);
	printf("在线性表L-Data[0]插入77\n");
	printf("此时的线性表为："); 
	for(i=0;i<Length(L);i++)
		printf("%d ",L->Data[i]);
	printf("\n");
	printf("查找值为12的下标是：%d\n",Find(12,L));
	printf("下标为3的线性表的值是：%d\n",FindKth(3,L));
	Delete(2,L);
	printf("删除线性表中下标为2的元素\n");
	Delete(2,L);
	printf("删除线性表中下标为2的元素\n");
	printf("此时的线性表为："); 
	for(i=0;i<Length(L);i++)
		printf("%d ",L->Data[i]);
	printf("\n"); 
	return 0;
}

4.顺序存储的优缺点

优点：
随机访问特性，查找O(1)时间，存储密度高；
逻辑上相邻的元素，物理上也相邻；
无须为表中元素之间的逻辑关系而增加额外的存储空间；
缺点：
插入和删除需移动大量元素；
当线性表长度变化较大时，难以确定存储空间的容量；
造成存储空间的“碎片”

爱抖腿的小松鼠
关注
专栏目录
数据结构线性表（C++ ）
chaichai126的博客
10-24 637
我自由了
408数据结构——线性表之C++实现顺序表
long99920的博客
05-22 509
可修改main函数内的注释，测试相应的顺序表操作。 #include <iostream> using namespace std; #define initSize 10 // 顺序表初始容量 // 创建顺序线性表(顺序表),动态分配内存空间地址 typedef struct { int *array; // 指向顺序表的指针 int maxSize,length; // 顺序表最大容量,顺序表当前长度 }sqList;
数据结构——线性表(C++)
最新发布
dahulihuli的博客
03-04 1250
数据结构在逻辑结构上分为线性和非线性，例如链表、顺序表、串、数组都是线性的，他们的特点就是一对一，而非线性结构比如图和二叉树，他们的对应关系是一对多、多对多，这里介绍线性表的顺序表和链表、循环链表和双向链表，还有双向循环链表。链表尤其重要，很多结构都是以链表作为基础的，比如栈和队列。先写头文件，然后是功能实现的cppprivate:int length;return;i < n;
c++实现线性表完整代码
11-07
c++实现线性表完整代码，内涵注释，可视化操作线性表。
数据结构之线性表(C++实现)
单线程的Daniel的博客
07-27 551
数据结构之线性表线性表的特点线性表的基本操作操作的实现 线性表的特点 存在唯一的一个被称作“第一个”的数据元素 存在唯一的一个被称作“最后一个”的数据元素 除第一个外，集合中的每个数据元素均只有一个前驱 除最后一个元素外，集合中的每个数据元素均只有一个后继 线性表的基本操作 InitList(&L); 构造空的线性表L DestoryList(&L); 销毁...
基于C/C++语言数据结构之线性表（一）
weixin_30735391的博客
10-14 299
数据结构学习笔记： 数据结构的重要性：数据结构我感觉很重要，不仅仅是考试很重要，而且在以后程序员事业上都是尤为重要的，知乎上有网友评价数据结构是最重要的编程基本能力，没有之一。我感觉这个说法很对，并且大家都知道，数据结构与算法这种说法常常被大家使用，就是因为数据结构是算法的基本前提，不懂数据结构，算法肯定学的很毛糙，根本就没有真正的高效可言，那也自然称不上是算法啦。所以大家要重视数据结构，...
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
在《数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx》文档中，作者详细介绍了如何在C++中实现顺序表和单链表的基本操作，并提供了相应的代码示例。本文档适用于C++初学者以及准备期末考试的学生...
数据结构——线性表顺序存储结构（C++代码）
09-28
线性表是数据结构中最基础且重要的概念之一，它是由n（n≥0）个相同类型元素构成的有限序列。顺序存储结构则是线性表的一种常见实现方式，它将线性表中的元素按照一定的顺序存放在一块连续的内存区域中。这种存储...
数据结构——线性表
weixin_52008431的博客
04-04 866
线性表 线性表概述 线性表（List）：零个或多个数据元素的有限序列 注意： （1）线性表是一个序列——>元素之间是有顺序的 （2）若元素存在多个，则第一个元素无前驱，最后一个元素无后继 （3）每个元素有且只有一个前驱和一个后继 （4）线性表的有限的 线性表的长度 线性表元素的个数n（n>=0)定义为线性表的长度 注意：当n=0时，定义为空表 线性结构举例： 一年的12个月份（只算一年，不算这一年过了是新的一年）就可以看成一个线性表，以一月为起始，12月为结尾，首先12
数据结构——线性表类模板
12-19
线性表是计算机科学中一种基础且重要的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。在C++编程语言中，类模板被广泛用于实现抽象数据类型，它允许我们创建通用的数据结构，适用于多种数据类型。本主题将...
线性表（c++代码）
03-14
数据结构：线性表的创建、插入、查找、删除 vector的简单应用
线性表(C++)
lovecontry
09-07 161
复习一下线性表的简单操作，以数组为存储结构 文件"sqlist.h" #include &lt;istream&gt; using namespace std; const int LIST_INIT_SPACE=50; //存储空间初始分配量 const int LIST_INC_SPACE=10; //分配增量 template &lt;class T&gt; class Sq_lis...
《数据结构》C++代码 线性表
icedream61的专栏
11-27 1604
线性表，分数组和链表两种（官方名称记得是叫顺序存储和链式存储）。代码里天天用，简单写写。          首先是数组，分静态、动态两种，没什么可说的，注意动态的要手动释放内存就好了。          其次是链表，依旧分静态、动态。课内一般都是讲的是动态实现，但其实还有一种静态实现方法。动态实现剩内存，但是静态实现剩时间，考试的时候当然是要视情况而定的。但是我估计，课内考试应该不会去卡这
线性表 c++语言代码,《数据结构之线性篇》-线性表的C++实现
weixin_29310853的博客
05-22 295
#pragma once#ifndef _LIST_H_#define _LIST_H_#includeusing namespace std;templateclass List{public:List(int size);~List();void ClearList();bool isEmpty();//检测线性表是否为空int ListLength();//获取线性表的长度bool GetE...
数据结构之线性表（C++实现）
qq_47471199的博客
09-10 1057
顺序表 函数声明 List.h（顺序表的定义，各项功能和变量） #pragma once #ifndef LIST_H #define LIST_H #endif #define Elem int class List { public: List(int size);//创建线性表 ~List();//销毁线性表 void ClearList();//清空线性宝 bool ListEmpty();//判断线性表是否为空 int ListLengh();//获取线性表的长度 bool GetE
线性表（C++）
weixin_63198483的博客
11-14 3679
数据结构与算法--线性表的各项操作（C++)
2021-12-19 数据结构——线性表(中) (c++代码和c代码)
名幕新星的博客
12-20 871
1. 线性表的链式存储 不要求逻辑上相邻的两个元素物理上也相邻，通过"链"建立起数据之间的逻辑关系。线性表的链式存储结构的特点是==用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。==这就意味着，这些元素可以存在内存未被占用的任意位置。 链表的定义是递归的，它或者为空null，或者指向另一个节点node的引用，这个节点含有下一个节点或链表的引用，线性链表的最后一个结点指针为“空”（通常用NULL或“^”符号表示）。 插入、删除不需要移动数据元素，只需要修改"链" t
C++版--线性表
yysdsyl的专栏
06-17 1116
#include "head.h"#include "iostream.h"#define LIST_INIT_SIZE 100template class SqList{  private:   ElemType *elem;   int length;      int listsize;   public:   SqList(int max=LIST_INIT_SIZE);   ~S
线性表的C++实现
weixin_43207320的博客
03-30 841
一、实现功能 返回链表长度 在链表为尾部添加元素 插入元素 删除元素 按链表值从尾到头的顺序打印链表 清空链表 二、各功能详解 1、
C++实现数据结构：特殊线性表——栈、队列与串
"这是一份关于数据结构的C++版电子笔记，主要讲解了特殊线性表中的栈、队列和串的概念与实现。笔记详细介绍了栈的逻辑结构、抽象数据类型定义以及顺序存储结构，同时也探讨了两栈共享空间的问题及其解决方案。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值