【数据结构】线性表——顺序表与链表

已于 2024-06-06 00:51:57 修改
阅读量482 收藏 12
点赞数 16
分类专栏： 数据结构与算法 文章标签： c语言 链表 数据结构 笔记
于 2024-03-16 19:04:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChenZHIHAO_y/article/details/136767641
版权

线性表

目录

相关习题！！！：

  1. 习题见：数据结构（线性表习题1）、以及数据结构（线性表习题2）
  2. 详细一元多项式的操作方法见文章：【数据结构】一元多项式的表示与相加（无序输入 有序输出）

线性表
特征：有限、性质相同、逻辑关系是一对一

2.1线性表的线性表示和实现

2.1.1创建动态分配的一维数组（顺序存储结构）

定义：线性表顺序存储结构是用一组地址连续的存储单元依次存储线性表的数据元素

a 1 a_1 a1​的存放地址也是整个空间的起始地址
在这里插入图片描述

1.线性表的动态分配存储结构的定义
线性表的动态分配存储结构的定义代码如下：

//线性表的动态分配存储结构
#define LIST_INST_SIZE  100  //线性表储存空间的初始分配量
#define LIST_INCREMENT  10  //线性表储存空间的分配增量

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

2.创建一个新的 空的线性表 （顺序存储结构）

//创建一个新的 空的线性表 （顺序存储结构）
void InitList_Sq(SqList &L){

    L.elem = (int *)malloc(LIST_INST_SIZE*sizeof(int));
    //开辟空间后 就可以 直接 使用*(L.elem+i) 进行赋值 访问
    
    if(!L.elem){
        cout<<"存储空间开辟失败"<<endl;
        exit(0);
    }//存储空间开辟失败
    
    L.length = 0;       //现在是空表  空表长度为零
    L.listsize = LIST_INST_SIZE; //初始开辟的容量大小
   
}// InitList_Sq

3.赋值

//使用刚刚创建的线性表进行 赋值
void GiveValue_toList(SqList &L){
    //例如 进行1 2 3 ...的赋值 一直到 最大
    for(int i = 0;i<L.listsize;i++){
        *(L.elem+i) = i+1;
        //或写成L.elem[i]=i+1;
        //现在 elem是一个 一级指针  
        L.length++;         //更新表长
    }
}//赋值1 2 3一直到 最大容量

4.输出结果

//输出结果
void PrintValue_List(SqList &L){
    for(int i = 0;i<L.length;i++){
        cout<<*(L.elem+i)<<endl;
    }
    cout<<"输出完毕！"<<endl;
}

5.释放空间

//释放空间
void Free_Listsqace(SqList &L){
    free(L.elem);
}

主函数

//demo
int main()
{
    SqList L;
    InitList_Sq(L);     //创建一个新的线性表
    GiveValue_toList(L);//赋值
    PrintValue_List(L); //打印结果
    Free_Listsqace(L);//最后释放内存空间
    return 0;
}

2.1.2动态分配的一维数组（顺序存储结构）的插入、删除和查找

1.在i位置上 插入元素 e

插入一次平均移动数据：(n+n-1+…+n-i+1+…+1+0)/(n+1)=n/2 算法的时间复杂度 O(n) 插入操作数据移动量大

void ListInsert_Sq(SqList &L,int i ,int e){
    //判断插入位置的合法性
    //i为要插入的位置 第i位
    int *newbase,*p,*q;
    
    if(i<1||i>L.length+1) 
    	return;
    //如果当前空间已经满了 开辟新空间
    
    if(L.length>=L.listsize){
    	//新建	
        newbase =(int *)realloc(L.elem,(L.listsize+LIST_INCREMENT)*sizeof(int));
        
        if(!newbase) //新建失败
        	exit(0);
        	
        L.elem = newbase;
        L.listsize += LIST_INCREMENT;
    }
    
    q = L.elem+i-1; //记录插入位置的 地址
    
    for( p= L.elem+L.length-1 ;p>=q;p--)
        *(p+1)=*p;//从要插入的位置 元素向后移
    *q = e;//插入元素 e;
    ++L.length;//更新表长
    
}// 插入元素

插入元素

void InsertList (SqList &L, int i, int e)//线性表用指针数组实现
//在线性表的第i个数据元素前插入一个值为 x 的新元素
{ int j,*newbase;
    if ( i <1|| i>L.length+1) return -1;//检查插入位置i的合理性
    if (L.length==L.listsize) //检查空间是否够用
    {//空间不够用时，增大空间 
        newbase=(int*)realloc(L.elem,(L.listsize+LISTINCREMENT)* sizeof(int)); 
        if(newbase==0) exit(0); 
        L.elem=newbase;
        L.listsize= L.listsize+LISTINCREMENT;
    }
    //将an ～ ai顺序向下移动，为新元素让出位置
    for(j=L.length;j>=i;j--) 
    L.elem[j]=L.elem[j-1];
    L.elem[i-1]=e;//插入新元素
    ++L.length;//修改表长 
}

算法的时间复杂度O(n).插入操作数据移动量大

2.删除第i个元素

删除线性表的第 i 个数据元素

void DeleteList(SqList &L; int i){ //删除线性表的第 i 个数据元素
    int j;
    if(i<1 || i>L.length) //判断删除的数据元素是否存在
    { printf (＂不存在第 i 个元素＂);return;
    //直接返回，返回0代表要删除的元素不存在，没用删除任何数据
    } 
    for(j=i+1;j<=L.length;j++)
        L.elem[j-2]=L.elem[j-1]; //将ai₊₁～an顺序向上移动，从而删除ai
        //向前移动
    L.length--; //修改表长
}

//删除线性表的第 i 个数据元素ai ，e存放被删除的数据元素ai的值

int DeleteList2 (SqList &L; int i, int& e){
//删除线性表的第 i 个数据元素ai ，e存放被删除的数据元素ai的值
     int j;
     
     if(i<1 || i>L.length){
        //判断删除的数据元素是否存在
        printf (＂不存在第i个元素＂);
        return 0; ;//直接返回，返回0代表要删除的元素不存在，没用删除任何数据
    }
    
    e=L.elem[i-1]; //将第 i 个数据元素的值存入e 
    
    for(j=i+1;j<=L.length;j++)
        L.elem[j-2]=L.elem[j-1]; //将ai₊₁～an顺序向上移动，从而删除ai
        
    L.length--; //修改表长
    
    return 1; //删除成功
}//该函数执行结束后，e中存放原表中ai的值

算法的时间复杂度O(n).删除操作数据移动量大

3.查找元素 e

查找 如果有 找到第一个 就输出

int ListSearch(SqList L, int e){
//在线性表中的查找与给定值e相等的数据元素。若存在返回其位置序号1
    int i;
    for(i=1;i<=L.length;i++)
        if ( L.elem[i-1]== e) return i;//数据元素的序号与存放位置差 
    return -1; //没找到e
}      //从表尾向前查找也是可以的：
//时间复杂度 为O(n)

查找 如果有 有几个输出几个

int ListSearch(SqList L, int e){
//在线性表中的查找与给定值e相等的数据元素。若存在返回其位置序号1
    int i,count_e=0; 
    for(i=1;i<=L.length;i++){// 这里 i从1 开始 所以下面 括号里写[i-1]
        if ( L.elem[i-1]== e) {
            count_e++;
        }   
    }
    if(count_e) return count_e; 
    return -1; //没找到e
}      //从表尾向前查找也是可以的：
//时间复杂度 为O(n)

2.1.3 顺序存储的优缺点

顺序存储结构的优缺点：
优点 ·

  1. 逻辑相邻一定物理相邻 ·
  2. 可随机存取任一元素 ·
  3. 存储空间使用紧凑

缺点 ·插入、删除操作需要移动大量的元素 ·插入时要考虑空间问题，是否溢出

2.2链表

2.2.1 线性链表

线性表的单链存储结构
特点：逻辑相邻不一定物理相邻，只能顺序存取

保存头指针，设置尾结点

带表头结点的线性单链表:表头结点通常空着或存放特殊的信息，比如线性表的长度

表头结点的直接后继才是线性表的第一个数据元素

动态链表
动态链表的定义

动态链表的定义 定义链表类型 结构体

// 动态链表的定义 定义链表类型 结构体
typedef struct Node{
    int data;
    struct Node *next;
}Node,*LinkList;//可以定义一个 名字也为 LNode的链表吗？

//例如
//定义的时候
typedef struct node{
    //定义单链表中存放每个数据元素的结点类型
    int data ; // ElemType表示数据元素的类型
    struct node *next;
}Node, *LinkList;
//其中struct node 为结构体 类型  node为标识符 
//可以用Node 来定义结构体链表 或者 用LinkList结构体指针 来定义
//定义了个 结构体类型的指针

LinkList h,p;//定义指针类型变量
Node *q; //定义指针类型变量
/*定义指针类型变量时没有指向
实际的结点空间，必须初始化*/

补充 结构体中 typedef的使用

typedef struct Student
{
    char name[16];
    int age;
}stu;

//则 stu 等价于结构体类型 struct Student
// stu scc；等价于 struct Student scc；

//typedef结构体和结构体指针方式
typedef struct Student
{
    char name[16];
    int age;
}stu, *stu_p;
 
int main()
{
    stu a;
    a.age = 16;
    printf("%d\n", a.age);
 
    stu_p p;
    p = (Student *)malloc(sizeof(struct Student));
    p->age = 14;
    printf("%d\n", p->age);
    free(p);
 
    return 0;
}
//per 等价于 struct Person，perptr 等价于 struct Person*
单链表的基本操作

定义指针类型变量时没有指向实际的结点空间，必须初始化

赋值 初始化

在这里插入图片描述
在这里插入图片描述

创建动态链表 并初始化 p->data 为结点的值域 p->next为结点的指针域

//赋值方法
//1. malloc( )
p=(LinkList)malloc(sizeof(Node));
//或者
p2=(Node *)malloc(sizeof(Node));
//2. 赋值语句
q=p;
//把已经存在的结点地址p赋给一个指针变量 q,这样p和q指向同一个结点空间

有个疑问 链表最后一个的后继为什么是 NULL 而不是乱码（就是一个随意的地址）？
**

链表未结束的循环条件
typedef struct node{
    //定义单链表中存放每个数据元素的结点类型
    int data ; // ElemType表示数据元素的类型
    struct node *next;
}*LinkList;
LinkList p;//定义指针类型
p=h->next;
while(p!=NULL){
    p=p->next;//指针 p后移
}//或while(p)

在这里插入图片描述

查找

从表中第一个数据元素开始顺次比较直到找到x，或找到表尾
不可任意读取 必须顺序读取
∙查找：在头指针为h的带表头结点的单链表查找是否存在值为x的结点，若有则返回指向x结点的指针；否则返回NULL

LinkList p;//定义指针类型
p=h->next;
while(p!=NULL&&p->data!= e ){
    p=p->next;//指针 p后移
}//或while(p)
if(p!=NULL) cout<<"成功找到 e"<<endl;
else cout<<"未找到 e "<<endl;

//或者写成
LinkList p;//定义指针类型
p=h->next;
while(p!=NULL){
    if(p->data== e ) cout<<"成功找到 e"<<endl;
    p=p->next;//指针 p后移
}//或while(p)
cout<<"未找到 e "<<endl;

写成函数的形式

LinkList search(LinkList h, int x){
//在头指针为h的带表头结点的单链表中查找是否存在值为x的结点
    LinkList p;
    p=h->next;//线性表第一个数据元素结点地址 
    while(p!=NULL&&p->data!=x)
        p=p->next; //尚未找到，在下一个结点继续查找
    return p;
}
//时间复杂度O(n)
插入

在线性单链表的p结点之后插入一个新的结点x

void insert(LinkList &p，int x){

//在线性单链表的p结点之后插入一个新的结点x

    LinkList s;
    
    s=(LinkList)malloc(sizeof(Node));//生成结点空间s 
    s->data=x;//插入的数据x放入结点空间s     
    s->next=p->next; //p的直接后继为新插结点s的直接后继 
    p->next=s; //新插结点s为p的直接后继
    
}

在第i个 存储结点后 插入一个结点

void insert(LinkList &L,int i,int e){
//在在第i个 存储结点后 插入一个结点
    LinkList s,p;
    s=(LinkList)malloc(sizeof(Node));//生成结点空间s 
    p=L->next;
    while(p!=NULL){
        i--;
        if(i==0){
            break;
        }
        p=p->next;
    }
    if(i!=0){
        cout<<"i 输入非法"<<endl;
        return;
    }
    
    s->data=e;//插入的数据x放入结点空间s     
    s->next=p->next; //p的直接后继为新插结点s的直接后继 
    p->next=s; //新插结点s为p的直接后继
}
删除

删除线性单链表中p结点的 直接后继结点

void delete(LinkList &p){ 
//删除线性单链表中p结点的 直接后继结点
    if(p->next)//p结点的直接后继结点是否存在？
        {  //q为p的直接后继—被删结点 p🡪next=q🡪next;//p的直接后继改为q的直接后继 
        free(p->next);//释放直接后继的空间
    }            
}//我直接这样写行吗 ？
//下面是课件上的

void delete(LinkList &p){ 
//删除线性单链表中p结点的 直接后继结点
    LinkList q;
    if(p->next)//p结点的直接后继结点是否存在？
    {  
        q=p->next;//q为p的直接后继—被删结点 p🡪next=q🡪next;//p的直接后继改为q的直接后继 
        free(q);//释放q的空间
    }            
}

删除数据为 x

void del(LinkList &h,int x){ 
//在头指针为h的带表头结点的单链表中删除结点x
    LinkList p,q;
    p=h->next;//线性表的第一个数据元素 
    q=h;//p的前驱结点地址 
    while(p!=NULL){
        if(p->data==x){
            q->next=p->next;
            free(p);
            return;
        } 
        else{
            q=p;
            p=p->next;
        }
    }
}

删除所有数据为 x

void del(LinkList &h,int x,int &count){ 
//在头指针为h的带表头结点的单链表中删除结点x    
    count=0;
    LinkList p,q;
    p=h->next;//线性表的第一个数据元素 
    q=h;//p的前驱结点地址 
    while(p!=NULL){
        if(p->data==x){
            q->next=p->next;
            free(p);
            p=q->next;
            count++;
        } 
        else{
            q=p;
            p=p->next;
        }
    }
}

链表特点：插入和删除均不需要移动数据

相关习题！！！：

  1. 习题见：数据结构（线性表习题1）、以及数据结构（线性表习题2）
  2. 详细一元多项式的操作方法见文章：【数据结构】一元多项式的表示与相加（无序输入 有序输出）
Chen_devy
关注
  • 16
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
php数据结构之顺序链表与链式线性表示例
10-18
顺序链表和链式线性表是数据结构领域中的基本概念，它们是存储和处理数据集合的两种常用方式。 ### 顺序链表 顺序链表是链表的一种特殊形式，它利用物理位置的相邻性来表示数据元素之间的逻辑关系。在顺序链表中，...
线性表——顺序表PPT学习教案.pptx
10-04
线性表可以分为顺序表和链表两种存储结构，今天我们主要讨论顺序表。 1. 线性表的定义 线性表是具有相同数据类型的n(n≥0)个数据元素组成的有限序列。数据元素之间具有的逻辑关系为线性关系的数据元素集合称为...
数据结构实验 顺序表和链表
10-08
数据结构实验 顺序表和链表中，我们可以学习到顺序表和链表的基本操作，包括创建、初始化、销毁、求长、判空、输出、获取元素、插入元素和删除元素等操作。下面是对顺序表和链表的详细介绍： 顺序表是一种线性表，...
数据结构学习--线性表及其应用--链表
06-25
线性表是一种基础的数据结构，它是由n（n>=0）个相同类型元素构成的有限序列。在计算机科学中，线性表可以采用顺序存储结构或链式存储结构来实现。本篇主要讨论的是链式存储结构的线性表，也就是链表。 链表是一种...
数据结构实验线性表（用java创建顺序表与链表并解决实验题目）
05-10
（1）创建一个顺序表，存放在数组 A[N]中，元素的类型为整型，设计算法调整 A，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空间复杂度均为 O(n)）。 （2）建立一个循环单链表，其节点...
嵌入式初学-C语言-数据结构--五
MaBaB的博客
09-09 778
队列是最常见的概念，日常生活经常需要排队，仔细观察队列会发现，队列是一种逻辑结构，是一种 特殊的线性表。特殊在：只能在固定的两端操作线性表 只要满足上述条件，那么这种特殊的线性表就会呈现一种“先进先出”的逻辑，这种逻辑就被称为队列。由于约定了只能在线性表固定的两端进行操作，于是给队列这种特殊的线性表的插入删除，起个特殊 的名称：队头：可以删除节点的一端队尾：可以插入节点的一端入队：将节点插入到队尾之后，函数名通常为enQueue()出队：将队头节点从队列中剔除，函数名通常为outQueue()
C语言常用头文件的介绍
weixin_45639224的博客
09-06 1208
C语言常用头文件的介绍
6.1.数据结构-c/c++堆详解下篇（堆排序，TopK问题）
yzc的博客
09-05 927
详解了推有关的两个面试题：堆排序，TopK问题
C++笔记18•数据结构:AVL树•
qq_64446190的博客
09-06 441
AVL树
栈—数据结构
weixin_63722559的博客
09-06 941
6、获取栈顶元素（获取栈顶元素，在外面开一个空间，将该空间的地址传过去，进行获取元素，以便于区分元素还是返回值）入栈的方向是是增栈的方式，放入数据的是满栈的方式。入栈的方向是是减栈的方式，放入数据的是满栈的方式。入栈的方向是是增栈的方式，放入数据的是空栈的方式。入栈的方向是是减栈的方式，放入数据的是空栈的方式。3、出栈（看一下，出去的元素，所以和6一样）1、入栈：先放入输入，再移动栈顶指针。2、出栈：先移动栈顶指针，再数据弹出。1、入栈：先挪栈顶指针，再放入数据。2、出栈：先移出数据，再移动指针。
数据结构之红黑树的 “奥秘“
最新发布
robin_suli的博客
09-09 596
红黑树在经常进行增删的结构中性能比 AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。红黑树不追求绝对平衡，其只需保 证最长路径不超过最短路径的2倍(相对平衡)每个结点上增加一个存储位表示结点的颜色。红黑树和AVL树都是高效的平衡二叉树。没有一条路径会比其他路径长出俩倍。先grandParent右旋。围绕红黑树上面的几条性质。
[数据结构] 开散列法 && 闭散列法 模拟实现哈希结构（一）
水墨不写bug
09-09 846
[数据结构] 开散列法 && 闭散列法 模拟实现哈希结构
数据结构之“双向链表”
2402_83250773的博客
09-06 912
双向链表，顺序表与链表的比较
【数据结构】基本概念和术语
Sakura_ding的博客
09-09 719
是指一个数学模型以及定义在该模型上的一组操作。抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关，即不论其内部结构如何变化，只要它的数学特性不变，都不影响其外部的使用。抽象数据类型和数据类型实质上是一个概念。“抽象”的意义在于数据类型的数学抽象特性。抽象数据类型的定义由一个值域和定义在该值域上的一组操作组成。若按其值的不同特性，可细分为下列三种类型：原子类型 (atomic data type)属原子类型的变量的值是不可分解的。
数据结构 栈 队列
qq_69971969的博客
09-06 603
数据的插入--->入栈 数据的删除----->出栈。函数的调用关系（保护现场，恢复现场操作，遵循先进后出，后进先出）缓存数据：主要使用队列，类似于缓冲区，防止数据丢失。允许从一端插入数据，另一端删除数据的线性存储结构。只允许从一端进行数据的插入和删除的线性存储结构。增栈 减栈：用栈顶的增长方向区分（移动方向）顺序队列：假溢出------>循环队列。满栈 空栈：栈顶所在位置是否存有元素。增栈：从内存低地址向高地址移动。减栈：从内存高地址向低地址移动。链式队列：用链表方式构造队列。
Redis常见的数据结构
weixin_61669379的博客
09-09 672
Redis底层的数据结构是Redis高效存储和操作数据的基础,Redis提供了五种基本的数据类型，每种类型在底层都有对应的数据结构来实现。这五种数据类型分别是：字符串（String）、哈希（Hash）、列表（List）、集合（Set）和有序集合（Sorted Set）。
数据结构————哈希表
qq_63843346的博客
09-09 538
也被称为散列表，是一种根据关键值（Key value）而直接进行访问的数据结构。它通过把关键值映射到表中的一个位置来访问记录，从而加快查找的速度。这个映射函数被称为散列函数或哈希函数，而存放记录的数组则被称为散列表或哈希表。
数据结构————栈、队列
qq_63843346的博客
09-06 805
在使用数组实现的队列中，如果队列的尾部已经到达数组的末尾，但数组的前部仍有空闲空间，此时队列将无法继续入队，产生假溢出。：特别是在使用数组实现的队列中，如果队列的长度远小于数组的长度，那么数组的大部分空间将被浪费。：虽然队列的遍历通常比栈更简单（因为不需要额外的空间来保存遍历过程中的元素），但在某些情况下（如需要频繁遍历队列），队列的遍历效率可能不是最优的。即最早插入队列的元素将会是第一个被移除的。：栈的遍历通常需要额外的空间来保存遍历过程中的元素，因为栈的后进先出特性使得遍历过程与元素的自然顺序相反。
数据结构-----栈、队列
2301_77841194的博客
09-06 266
1、栈(stack)是限定仅在表尾进行插入和删除操作的线性表。把允许插入和删除的一端称为栈顶（top)，另一端称为栈底（bottom)，不含任何数据元素的栈称为空栈。栈又称为后进先出（Last In First Out)的线性表,简称LIFO结构。2、栈的插入操作：叫作进栈,也称压栈、入栈示。栈的删除操作：叫作出栈,也有的叫作弹栈。满栈、空栈：栈顶所在位置是否存有元素增栈、减栈：栈的增长方向。
数据结构实验：线性表操作与实现——顺序表与链表
"该文档是关于浙江理工大学数据结构实验，主要关注线性表的操作与实现。实验分为两部分，一是顺序表的操作，包括创建、查找、插入和删除，以及顺序表的反转；二是链表的操作，同样涉及创建、输出、反转等。实验要求...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Chen_devy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值