数据结构与算法学习笔记-一般线性表

原创 已于 2022-01-27 16:10:58 修改 · 775 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#数据结构 #算法
于 2022-01-27 15:33:05 首次发布
本文详细介绍了线性表的基本概念、顺序存储结构及链式存储结构，并深入探讨了单链表、双链表、循环链表的创建、基本运算及应用实例。

定义

线性表是一个具有相同特性的数据元素的有限序列

  • 相同特性：所有元素属于同一数据类型

  • 序列：数据元素由逻辑序号唯一确定，一个线性表中可以由相同值的元素

顺序存储结构

顺序表和线性表的区别：顺序表是物理结构，线性表是逻辑结构

 

算法实现

顺序表

  1. 类型定义

  2. 创建顺序表

     void CreateList(SqList *&L,ElemType a[],int n){
     int i;
     L=(SqList *)malloc(sizeof(SqList));
     for(i=0;i<n;i++)
         L->data[i]=data[i];
     L->length=n;
 }

线性表基本运算

  1. 初始化线性表

     void InitList(SqList *&L){
     L=(SqList *)malloc(sizeof(SqList));
     L->length=0;
 }

  2. 销毁线性表

     void DeList(SqList *&L){
     L=(SqList *)malloc(sizeof(SqList));
     L->length=0;
 }

  3. 判断是否为空表

    bool isEmpty(SqList *L){
     if(L->length==0){
         return 1;
     }else{
         return 0;
     }
 }

  4. 求线性表的长度

     int ListLength(SqList *L){
     return (L->length);
 }

  5. 输出线性表

     void DispList(SqList *L){
     int i;
     if(L->length==0)
         return;
     for(i=0;i>(L->length);i++){
         printf("%c",L->data[i]);
     }
     printf("\n");
 }

  6. 求某个数据元素值

     bool GetElem(SqList *L,int i,ElemType &e){
     if(i<1||i>L->length) return false;
      e=L->data[i-1];
     return true;
 }

  7. 按元素值查找

     int GetByValue(SqList *L,ElemType e){
     int i=0;
     whlie(i<L->length&&L->data[i]!=e)
         i++;
     if(i>=L->length) return 0;
     else return 1;
 }

  8. 插入数据元素

     int GetByValue(SqList *L,ElemType e){
     int i=0;
     whlie(i<L->length&&L->data[i]!=e)
         i++;
     if(i>=L->length) return 0;
     else return 1;
 }

  9. 删除数据元素

     bool ListDelete(SqList &*L,ElemType e,int i){
     int j;
     if(i<1||i>L->length){
         return false;
     }
     i--;
     for(j=i;j<L->length-1;j++)
         L->data[j]=L->data[j+1];
     L->length--;
     return true;

链式存储结构

一、链表

线性表中每个结点有唯一的前驱结点和后驱结点（每个结点增加一个指向后继结点的指针域——单链表；每个结点增加一个指向后继结点的指针域和一个指向前继结点的指针域——双链表）

带头结点的单链表的优点：

  • 第一个结点的操作和其他结点一致

  • 把空表和非空表的处理统一起来了

存储密度：

结点中数据部分的存储空间/结点存储总空间

单链表

（无法访问前一个结点）

typedef struct LNode{
     ElemType data;
     struct LNode *next;//指向下一个结点
 } LinkList;

  1. 插入结点

  2. 删除结点

  3. 头插法建表（先建一个头结点，把新结点插入到当前链表的表头上。这样的话链表的物理顺序和逻辑顺序相反)

     void CreateListF(LinkList *&L,ElemType a[],int n){
     LinkList *s;
     int i;
     L=(LinkList)malloc(sizeof(LinkList)); //创建头结点
     L->next=NULL;
     for(i=0;i<n;i++){
         s=(LinkList *)malloc(sizeof(LinkList));
         // 创建新结点
         s->data[i]=a[i];
         s->next = L->next;
         L->next=s;
     }  
 }

  4. 尾插法建表（增加一个尾指针始终指向当前链表的尾结点，将新结点插入到当前链表的尾部）

     void CreateLisR(LinkList *&L,ElemType a[],int n){
     LinkList *s,*r;
     int i;
     L=(LinkList*)malloc(sizeof(LinkList)); //创建头结点
     L->next=NULL;
     r=L;                        //尾结点开始时指向头结点
     for(i=0;i<n;i++){
         s=(LinkList *)malloc(sizeof(LinkList));
         // 创建新结点
         s->data=a[i];
         r->next=s;
         r=s;
     }  
     r->next= NULL;
 }

线性表基本运算

  1. 初始化线性表

     void InitList(LinkList *&L){
     L=(LinkList *)malloc(sizeof(LinkList));
     L->next=NULL;
 }

  2. 销毁线性表

     void DestroyList(LinkList *&L){
     LinkList *pre=L,*p = L->next;
     while(p!=NULL){
         free(pre);
         pre=p;
         p=pre->next; 
     }
     free(pre);
 }

  3. 判断线性表是否为空

     book IsEmpty(LinkList *L){
     return(L->next==NULL);
 }

  4. 求线性表长度

     int ListLength(LinkList *L){
     int i=0;
     LinkList *p=L;
     while(p->next!=NULL){
         i++;
         p=p->next;
     }
     return i;
 }

  5. 输出线性表

     void DisList(LinkList *L){
     LinkList *p=L->next;
     if(p!=NULL){
         printf("%d",p->data);
         p=p->next;
     }
     printf("\n");
 }

  6. 求线性表中某一位置的元素

     bool FindElem(LinkList *L,int i,ElemType &e){
     int j=0;
     LinkList *p=L;
     while(j<i&&p!=NULL){
         j++;
         p=p->next;
     }
     if(p==NULL)
         return false;
     else
         e=p->data;
     return true;
 }

  7. 求线性表中某一值的元素的所在位置

     int LocateElem(LinkList *L,ElemType e){
     int i=1;
     LinkList *p=L->next;
     while(p!=NULL&&p->data!=e){
         p=p->next;
         i++;
     }
     if(p==NULL){
         return -1;
     }else{
         return i;
     }
 }

  8. 插入数据元素

     bool InsertList(LinkList *&L,int i,Elemtype e){
     int j=0;
     LinkList *p=L,*s;
     while(j<i-1&&p!=NULL){
         p=p->next;
         j++;
     }
     if(p==NULL)
         return false;
     else{
         s=(LinkList *)malloc(sizeof(LinkList));
         s->data=e;
         s->next=p->next;
         p->next=s;
         return true;
     }
 }

  9. 删除数据元素

     bool DelEltem(LinkList *&L,int i，Elemtype &e){
     int j=0;
     LinkList *p=L,*s;
     while(j<i-1&&p!=NULL){
         j++;
         p=p->next;
     }
     if(p==NUll){
         return false;
     }else{
         q=p->next;
         if(q==NULL){
             return false;
         }
         e=q->data;
         p->next=q->next;
         free(q);
         return true;
     }
 }

  10. 使单链表递增排序

     void sort(LinkList *&L){
     LinkList *p,*pre,*q;
     p=L->next->next;
     L->next->next=NULL;
     while(p!=NULL){
         q=p->next;
         pre=L;
         if(pre->next!=NULL&&pre->next->data<p->data)
             pre=pre->next;
         p->next=pre->next;
         pre->next=p;
         p=q;
     }
 }

  11. 单链表倒序（采用头插法）

     void Reverse(LinkList *&L){
     LinkList *p=L->next , *q;
     L->next=NULL;
     while(p!=NULL){
         q=p->next;
         p->next=L->next;
         L->next=p;
         p=q
     }
 }

  12. 例题

     

     

 void split(LinkList *&L,LinkList *&L1,LinkList *&L2){
     LinkList *p=L->next, *r1, *q;
     L1=L;
     r1=L1;
     L2=(LinkList *)malloc(sizeof(LinkList));
     L2->next=NULL;
     while(p!=NULL){
         //尾插法
         r1->next=p;
         r1=p;
         p=p->next;
         //头插法
         q=p->next;
         p->next=L2->next;
         L2->next=p;
         p=q;
     }
     r1->next=NULL;
 ​
 }

荷兰国旗问题

用顺序表存储

 

 
void flag(SqList *&L){
     int i=-1,j=0,k=L->length;
     while(j<k){
         if(L->data[j]==0){
             i++;
             swap(L->data[i],L->data[j]);
             j++;
         }
         else if(L->data[j]==2){
             k--;
             swap(L->data[k],L->data[j])
         }
         else{
             j++;
         }
     }
 }

链表存储

void flag(LinkList *&L){
     LinkList *p,*L1,*L2,*r,*r1,*r2;
     L1=NULL;
     L2=NULL;
     p=L->next;
     r=L;
     whlie(p!=0){
         if(p->data==0){
             r->next=p;
             r=p;      
         }
         else if(p->data==1){
             if(L1==NULL){
                 L1=p;
                 r1=p;
             }
             else{
                 r1->next=p;
                 r1=p;
             }
         }
         else if(p->data==2){
             if(L2==NULL){
                 L2=p;
                 r2=p;
             }
             else{
                 r2->next=p;
                 r2=p;
             }
         }
         p=p->next;
     }
     r->next=r1->next=r2->next=NULL;
     //连接三个链表
     r->next=L1;
     L1->next=L2;
 }

双链表

定义

双链表结点的插入和删除

 

创建双链表

  1. 头插法

     void CreateList(DLinkList *&L,ElemType a[],int n){
     DLinkList *s;
     int i;
     L=(DLinkList *)malloc(sizeof(DLinkList));
     for(i=0;i<n;i++){
         s=(DLinkList *)malloc(sizeof(DLinkList));
         s->data=a[i];
         s->next=L->next;
         if(L->next!=NULL){
             L->next->prior=s;
         }
         L->next=s;
         s->prior=L;
     }
 }

  2. 尾插法

     
    void CreateList(DLinkList *&L,ElemType a[],int n){
     DLinkList *s,*r;
     int i;
     L=(DLinkList *)malloc(sizeof(DLinkList));
     r=L;
     for(i=0;i<n;i++){
         s=(DLinkList *)malloc(sizeof(DLinkList));
         s->data=a[i];
         r->next=s;
         s->prior=r;
         r=s;
     }
     r->next=NULL;
 }

基本运算

  1. 双链表的插入

     

    bool insertList(DlinkList *&L,int i,ElemType e){
     int j=0;
     DLinkList *p=L,*s;
     while(j<i-1 && p!=NULL){
         j++;
         p=p->next;
     }
     if(p==NULL){
         return false;
     }
     else{
         s=(DLinkList *)malloc(sizeof(DLinkList));
         s->data=r;
         s->next=p->next;
         if(p->next!=NULL){
             p->next->piror=s;
         }
         s->prior=p;
         p->next=s;
         return true;
     }
 }

  2. 双链表的删除

     
    bool DelList(DlinkList *&L,int i,ElemType &e){
     int j=0;
     DLinkList *p=L,*q;
     while(j<i-1 && p!=NULL){
         j++;
         p=p->next;
     }
     if(p==NULL){
         return false;
     }
     else{
         q=p->next;
         if(q==NULL)
             return false;//不存在第i个结点
         e=q->data;
         p->next=q->next;
         if(p->next!=NULL)
             p->next->prior=p;
         free(p);
         return true;
     }
 }

  3. 双链表逆序（头插法）

     void Reverse(DLinkList *&L){
     DLinkList *p=L,*q;
     L->next=NULL;
     while(p!=NULL){
         q=p->next;
         p->next=L->next;
         if(L->next!=NULL){
             L->next->prior=p;
         }
         L->next=p;
         p->piror=L;
         p=q;
     }
 }

链表操作都需要一个指向链表结点p指针来遍历结点，后插法创建需要一个r指针指向最后一个结点，删除一个节点和头插法逆序链表时需要q指针来保存p->next的结点（因为p->next会被赋值）

循环链表

 

循环链表对于频繁操作头尾的程序会提高执行效率

两张表自然连接问题

 

数据结点定义

 #define MaxCol 10
 typedef struct Node1{
     ElemType data[MaxCol];
     struct Node1 *next;
 }DList;

头结点定义

typedef struct Node2{
     int Row,Col;
     DList *next;
 }HList;

  1. 交互式创建单链表

     

    void CreateTable(HList *&h){
     int i,j;DList *s,*r;
     h=(HList *)malloc(sizeof(HList));
     h->next=NULL;
     print("行数，列数：");
     scanf("%d%d",&h->Row,&h->Col);
     for(i=0;i<h->Row;i++){
         printf("第%d行",h->Row);
         s=(DList *)malloc(sizeof(DList));
         for(j=0;j<h->Col;j++){
            scanf("%d",&s->data[j]);
         }
         if(h->next==NULL){
             h->next=s;
         }else{
             r->next=s;
         }
         r=s;
     }
     r->next=NULL;
 }

  2. 销毁单链表

     

    void DestoryList(HList *&h){
     DList *pre=h->next,*p=pre->next;
     if(p!=NULL){
         free(pre);
         pre=p;
         p=p->next;
     }
     free(pre);
     free(h);
 }

  3. 输出单链表

     
    void DispTable(HList *h){
     int j;
     DList *p=h->next;
     whlie(p!=NULL){
         for(j=0;j<h->Col;j++){
             printf("%4d",p->data[j]);
         }
         printf("\n");
         p=p->next;
     }
 }

  4. 实现两个单链表的自然连接运算

     
    void LinkTable(HList *h1,HList *h2,HList *h){
     int i,j,k;
     DList *p=h1->next,*q,*r,*s;
     printf("连接字段是：第1个表序号，第二个表序号");
     scanf("%d%d",&i,&j);
     
     h=(HList *)malloc(sizeof(HList));
     h->next=NULL;
     h->Row=0;
     h->Col=h1->Col+h2->Col;
     
     while(p!=NULL){
         q=h2->next;
         while(q!=NULL){
             if(p->data[i-1]==q->data[j-1]){
                 s=(DList *)malloc(sizeof(DList));
                 for(k=0;k<h1->Col;k++){
                     s->data[k]=p->data[k];
                 }
                 for(k=0;k<h2->Col;k++){
                     s->data[h1->Col+k]=q->data[k];
                 }
                 if(h->next==NULL)
                     h->next=s;
                 else
                     r->next=s;
                 r=s;
                 h->Row++;
             }
             q=q->next;
         }
         p=p->next;
     }
     r->next=NULL;
 }

有序表

定义：所有元素以递增或递减的方式有序排列。

若以顺序表来存储有序表，和线性表的区别在于插入算法不同。（因为没有插入位置参数，插入后不能确定有序表依然有序）



while(i< L->length && L->data[i]<e)  //这里小于号保证了有序

以链表来存储有序表和顺序表的特点相同。

有序表的归并算法

  • 有两个有序表LA，LB。设计一个算法，将他们合并成一个有序表LC.

顺序表存储

 
void UnionList(SqList *LA,SqList *LB,SqList *LC){
     int i=0,j=0,k=0;
     LC=(SqList *)malloc(sizeof(SqList));
     while(i<LA->length&&j<LB->length){
         if(LA->data[i]<LB->data[j]){
             LC->data[k]=LA->data[i];
             i++,k++;
         }
         else{
             LC->data[k]=LB->data[j];
             j++,k++;
         }
     }
     while(i<LA->length){
         LC->data[k]=LA->data[i];
         i++,k++;
     }
     while(j<LB->length){
         LC->data[k]=LB->data[j];
         j++,k++;
     } 
     LC->length=k;
 }

链表存储

 

freak2020
关注
线性表（c语言）
m0_59962646的博客
12-29 1180
线性表
数据结构与算法 - 线性表
m0_46478866的博客
03-27 4251
数据结构与算法 - 线性表前言第1关：实现一个顺序存储的线性表第2关：实现一个链接存储的线性表总结 前言 线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中，数据元素之间通过一对一首尾相接的方式连接起来。具体实现时，线性表可以采用顺序存储，也可以采用链接存储。本实训项目的主要目标是学习和掌握基于 C 语言实现线性表，主要内容包括基于顺序存储和链接存储的方式来实现线性表。 提示：以下是本篇文章正文内容，下面案例可供参考 第1关：实现一个顺序存储的线性表 本关任务：实现 step1/Seqlist
数据结构的删除操作
weiker12的专栏
08-06 3945
1.顺序表的删除： bool ListDelete(SqList *&L,int i,ElemType &e) //删除数据元素 { int j; if (i L -> length) //参数错误时返回false return false; i--; //将顺序表逻辑序号转化为物理序号 e = L -> data[i]; for (j = i;j length
数据结构（线性表：顺序表详解）
qq_66298799的博客
09-10 2796
本篇文章讲解线性结构中最简单、最普通的结构：顺序表。尽自己个人最大的努力，让读者看懂。
leetcode 刷题笔记一
u011376686的博客
01-18 374
leetcode81. Search in Rotated Sorted Array II 题目意思是：根据某个值旋转数组，在新的数组中查找某个元素 输入的数组可能是排好序的，也可能是排序之后旋转的 旋转数组由中间数划分：一定有一个区间是顺序的，判断target比这个区间最小数小，比最大数大，则不在该区间中，改变l或者r。 public boolean search(int[] nums,
数据结构复习 -- 顺序表
森宝的博客
07-23 578
#include <iostream> #include <cstdio> #include <cstdlib> using namespace std ; typedef int ElemType ; const int MaxSize = 200; // const int InitSize = 50 ; typedef struct { ElemType data[MaxSize] ; int length ; }SqList; //.
数据结构—一般线性表的合并
小虾米编程
06-21 1万+
1.一般线性表的合并 问题描述：假设利用两个线性表La和Lb分别表示两个集合A和B,现要求一个新的集合 A=A∪B。 La=(7, 5, 3, 11) Lb=(2, 6, 3) La=(7, 5, 3, 11, 2, 6) 算法步骤： 依次取出Lb中的每个元素，执行以下操作： 在La中查找该元素 如果找不到，则将其插入La的最后 2.顺序表实现 //合并 void...
数据结构与算法——线性表（顺序表篇）
小田是个程序员的博客欢迎你的到来呀~
06-11 8265
线性表且最简单的一种数据结构， 一个线性表是n个数据元素的有限序列 。本篇文章主要详细解读了线性表的基本概念，以及线性表中顺序表的重点知识。详细分析了顺序表的基本操作，图文结合，易于理解。............
python数据结构与算法总结
热门推荐
python之战
04-24 2万+
python常用的数据结构与算法就分享到此处，本月涉及数据结构与算法的内容有如下文章： 《数据结构和算法对python意味着什么？》 《顺序表数据结构在python中的应用》 《python实现单向链表数据结构及其基本方法》 《python实现单向循环链表数据结构及其方法》 《python实现双向链表基本结构及其基本方法》 《python实现双向循环链表基本结构及其基本方法》 《py...
数据结构与算法
子羽丿_的博客
08-13 5195
数据结构与算法一、基本概念1.1、数据结构起源1.2、数据结构1.3、数据结构基本概念1.4、数据结构三要素二、线性表（逻辑结构）2.1、线性表的概念2.2、顺序表2.3、链表2.4、顺序表 vs 链表2.5、双链表2.6、循环链表三、栈 stack3.1、栈的概念及特点3.2、顺序栈3.3、链式栈四、队列 queun4.1.队列的概念及特点4.2. 顺序队列的基本操作4.3. 链式队列的基本操作五、树5.1、树的定义：5.2、二叉树特点：5.3、二叉树遍历六、图6.1、图的概念6.2. 图的存储6.3.
《数据结构》一般线性表的合并
千言万语ROOM
03-05 1万+
一般线性表的合并 算法思想： 遍历表A和表B，查看B的每一个元素是否在A中，若不在，将B的该元素插入到A的表尾，A表的表长+1。 算法的时间复杂度和A、B的长度有关，O（m*n）. //合并 void Combine(SqList &A,SqList &B){ for(int i=0;i<B.length;i++){ int count=0; for(int j=0;j<A.le
数据结构与算法学习笔记 之 程杰《大话数据结构》数据结构篇
MuscleMonk的博客
07-26 1458
数据结构与算法学习笔记 之 程杰《大话数据结构》 第一章 数据结构绪论 数据项：数据不可分割的最小单位。在数据结构课程中，把数据项定义为最小单位，有助于我们更好地解决问题。但是真正讨论问题时，数据元素才是数据结构中建立数据模型的着眼点。 数据对象：是性质相同的数据元素的集合，是数据的子集。其中，性质相同是指数据元素具有相同数量和类型的数据项。 结构：各个组成部分相互搭配和排列的方式。 数据结构：相互之间存在一种或多种特定关系的数据元素的集合。 数据类型：是指一组性质相同的值的集合及定义在此集合上的一些操作
【PTA】【数据结构与算法】线性表
葑鈊丶
05-17 9373
这里是从PTA平台整理的【线性表】题目集
数据结构的C语言实现-线性表的合并与排序
DavidGarrett的博客
07-20 4674
一、线性表简介： 1、线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列 2、线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储，但是把最后一个数据元素的尾指针指向了首位结点） 二、线性表的一般操作： （1） InitList(& L)
数据结构中 线性表，栈，队列，算法之间的联系与区别
qq_35810838的博客
11-25 3647
一。链表为什么需要         在程序中，经常需要将一种（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录他们，传进传出函数等。一组元素可能发生变化（像增加或删除元素。）        对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中的某种意义的信息，或者表示数据之间的某种关系。        这样的...
【数据结构算法】④、线性表算法练习篇、数据结构与线性表练习题-单选题+简答题、线性表算法练习题
慢慢来就很快。
03-23 3589
【数据结构算法】④、线性表算法练习篇、数据结构与线性表练习题-单选题+简答题、线性表算法练习题
数据结构、算法与应用
王文萱的博客
03-23 3233
目录 一、绪论 1.1 什么是数据结构 1.1.1 数据的逻辑结构 1.1.2 数据的存储结构 1.2 算法与算法设计 1.3 算法分析 二、线性表 2.1 线性表的基本概念 2.2.1 线性表的定义 2.2.2 线性表的存储结构 2.2 顺序表 2.3 链表 2.3.1 链表的实现 2.3.2 线性表实现方法的比较 2.4 栈 2.4.1 顺序栈 2.4...
《数据结构与算法》——数组长度与线性表长度区别
qq_41899773的博客
03-14 2931
数组长度与线性表长度区别 数组的长度是存放线性表的存储空间的长度，存储分配后这个量一般是不变的。有个别同 学可能会问，数组的大小一定不可以变吗？我怎么看到有书中谈到可以动态分配的一维数 组。是的，一般高级语言，比如C、VB、C++都可以用编程手段实现动态分配数组，不过 这会带来性能上的损耗。 线性表的长度是线性表中数据元素的个数，随着线性表插入和删除操作的进行，这个量是...
数据结构于算法—线性表
bigsai
08-04 4801
通过前面[数据结构与算法前导](https://blog.csdn.net/qq_40693171/article/details/96913019)我么知道了数据结构的一些概念和重要性，那么我们今天总结下线性表相关的内容。当然，我用`自己的理解解`分享给大家。 - 其实说实话，可能很多人依然分不清`线性表，顺序表，和链表`之间的区别和联系！ - 线性表：`逻辑结构`， 就是对外暴露数据之间的关系，不关心底层如何实现。 - 顺序表、链表：`物理结构`，他是实现一个结构实际物理地址上的结构。比如顺序表
数据结构与算法总结——线性表
最新发布
sinat_39377093的博客
07-22 2110
数据结构与算法之线性表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值