王道数据结构（第二章：线性表）

已于 2024-04-21 21:49:39 修改
阅读量245 收藏
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 c++ 算法
于 2024-04-19 16:22:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ggsfsa/article/details/137969402
版权

  • 2.2线性表的顺序表示


#include <stdlib.h>
#include <iostream>
using namespace std;
//顺序表的定义
#define InitSize 10
typedef struct{
    int element[InitSize];
    int length;
} SqList0;
//静态分配
void initList0(SqList0& l){
    l.length=0;
}
typedef struct{
    int* element;
    int MaxSize;
    int length;
} SqList1;
//动态分配
void initList1(SqList1& l){
    l.element=(int*)malloc(sizeof(int)*InitSize);
    l.MaxSize=InitSize;
    l.length=0;
}
//扩容
void increaseSize(SqList1& l,int length){
    int* q=l.element;
    l.element=(int*)malloc((l.MaxSize+length)*sizeof(int));
    for(int i=0;i<l.length;i++){
        l.element[i]=q[i];
    }
    l.MaxSize+=length;
    free(q);
}
//打印
void printList(SqList1& l){
    for(int i=0;i<l.length;i++)
        cout<<l.element[i]<<' ';
    cout<<endl<<"length："<<l.length<<endl;
}
//在位置i处插入数据
bool insertList(SqList1& l,int i,int e){
    if(i<1||i>l.length+1)return false;
    if(l.length>=l.MaxSize)return false;
    for(int j=l.length;j>=i;j--){
        l.element[j]=l.element[j-1];
    }
    l.element[i-1]=e;
    l.length++;
    return true;
}
//删除位置i的元素,用e存储删除的值
bool deletList(SqList1& l,int i,int& e){
    if(i<1||i>l.length)return false;
    if(l.length<=0)return false;
    e=l.element[i-1];
    for(int j=i;j<l.length;j++){
        l.element[j-1]=l.element[j];
    }
    l.length--;
    cout<<"删除的值为："<<e<<endl;
    return true;
}
//按位置查找
int locateElement0(SqList1& l,int i){
    return l.element[i-1];
}
//按值查找,返回下标
int locateElement1(SqList1& l,int e){
    for(int i=0;i<l.length;i++){
        if(l.element[i]==e)return i;
    }
    return -1;
}
int main()
{
    SqList1 L;//定义
    initList1(L);//初始化
    increaseSize(L,3);//扩容
    insertList(L,1,2);//插入
    insertList(L,2,3);
    insertList(L,3,0);
    insertList(L,4,9);
    printList(L);//打印
    
    int e=-1;
    deletList(L,2,e);//删除
    printList(L);
    cout<<"第2个位置为："<<locateElement0(L,2)<<endl;//查找
    cout<<"9这个值所在下标处："<<locateElement1(L,9)<<endl;
    return 0;
}

  • 2.3线性表的链式表示 


#include <iostream>
#include <cstdlib>
using namespace std;
//单链表
typedef struct LNode{
    int data;
    LNode* next;
}LNode,*LinkList;
//初始化(不带头结点的)
bool initList0(LinkList& L){
    L=NULL;//空表
    return true;
}
//初始化(带头结点的)
bool initList1(LinkList& L){
    L=(LNode*)malloc(sizeof(LNode));
    if(L==NULL)return false;//创建头节点失败
    L->next=NULL;
    return true;
}
//后插
bool insertNextNode(LNode* p,int i){
    if(p==NULL)return false;
    LNode* q=(LNode*)malloc(sizeof(LNode));
    if(q==NULL)return false;//创建失败
    q->data=i;
    q->next=p->next;
    p->next=q;
    return true;
} 
//前插
bool insertPriorNode(LNode* p,int i){
    if(p==NULL)return false;
    LNode* q=(LNode*)malloc(sizeof(LNode));
    if(q==NULL)return false;//创建失败
    q->next=p->next;
    p->next=q;
    q->data=p->data;
    p->data=i;
    return true;
}
//按位置插入（不带头结点）
bool ListInsert0(LinkList& L,int i,int e){
    if(i<1)return false;
    //对于第一个位置需要特殊处理
    if(i==1){
        LNode* s=(LNode*)malloc(sizeof(LNode));
        s->next=L;
        s->data=e;
        L=s;//新表的首位
        return true;
    }
    LNode* p=L;
    int j=1;
    while(p!=NULL&&j<i-1){
        p=p->next;
        j++;
    }//循环到i-1位置处跳出循环
    if(p==NULL)return false;//i的位置不合法
    //后插法即可
    return insertNextNode(p,e);
}
//按位置插入（带头结点）
bool ListInsert1(LinkList& L,int i,int e){
    if(i<1)return false;
    LNode* p=L;
    int j=0;
    while(p!=NULL&&j<i-1){
        p=p->next;
        j++;
    }//循环到i-1位置处跳出循环
    if(p==NULL)return false;//i的位置不合法
    //后插法即可
    return insertNextNode(p,e);
}
//按位置删除
bool delteNodeByLocation(LinkList& L,int i,int& e){
    if(i<1)return false;
    LNode* p=L;
    int j=0;
    while(p!=NULL&&j<i-1){
        p=p->next;
        j++;
    }
    if(p==NULL)return false;//i的位置不合法
    if(p->next==NULL)return false;//i-1之后放好没有节点
    LNode* q=p->next;
    e=q->data;
    p->next=q->next;
    free(q);
    return true;
}
//指定节点删除
bool deleteNode(LNode* p){
    if(p==NULL)return false;//如果指定节点是最后一个,则q节点为空不合法
    LNode* q=p->next;
    p->data=q->data;
    p->next=q->next;//p被后面节点的值覆盖
    free(q);//删除多余的节点
    //偷梁换柱
    return true;
}
//打印
void printList(LinkList& L){
    if(L==NULL)return;
    LNode* p=L->next;
    while(p!=NULL){
        cout<<p->data<<" ";
        p=p->next;  
    }
    cout<<endl;
}
//按位置查找，返回第i个元素
LNode* GetNodebyLocation(LinkList L,int i){
    if(i<0)return NULL;
    LNode* p=L;
    int j=0;
    while(p!=NULL&&j<i){
        p=p->next;
        j++;
    }
    return p;
}
//按值查找，返回值为e的节点
LNode* GetNodeByValue(LinkList L,int e){
    LNode* p=L->next;
    while(p!=NULL&&p->data!=e)
        p=p->next;
    return p;
}
//求表的长度
int length(LinkList L){
    int len=0;
    LNode* p=L;
    while(p!=NULL){
        p=p->next;
        len++;
    }
    return len;
}
int main(){
    LinkList L;//定义
    initList1(L);//有头节点初始化
    ListInsert1(L,1,1);//插入
    ListInsert1(L,1,2);
    ListInsert1(L,1,3);
    ListInsert1(L,1,9);
    printList(L);//打印
    int e=0;
    delteNodeByLocation(L,2,e);//按位置删除
    cout<<"e的值为："<<e<<endl;
    printList(L);
    deleteNode(L);//删除头节点
    printList(L);
    insertPriorNode(L,12);//前插
    printList(L);
    ListInsert0(L,2,2);//没有头节点的插入
    printList(L);
}

  • 2.3.2_3单链表的建立 


#include <iostream>
#include <cstdlib>
using namespace std;
//单链表
typedef struct LNode{
    int data;
    LNode* next;
}LNode,*LinkList;
//初始化单链表（带头结点的）
bool InitList(LinkList& L){
    L=(LNode*)malloc(sizeof(LNode));
    if(L==NULL)return false;
    L->next=NULL;
    return true;
}
//尾插法建立单链表
bool List_TailInsert(LinkList& L){
    int x;
    L=(LNode*)malloc(sizeof(LNode));
    LNode *s,*r=L;
    cin>>x;
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;
        cin>>x;
    }
    r->next=NULL;
    return L;
}
//头插法建立单链表
LinkList List_HeadInsert(LinkList& L){
    LNode* s;
    int x;
    L=(LNode*)malloc(sizeof(LNode));
    L->next=NULL;//初始化为空，很关键
    cin>>x;
    while(x!=9999){
        s=(LNode*)malloc(sizeof(LNode));
        s->next=L->next;
        L->next=s;
        s->data=x;
        cin>>x;
    }
    return L;
}
//打印
void printList(LinkList& L){
    if(L==NULL)return;
    LNode* p=L->next;
    while(p!=NULL){
        cout<<p->data<<" ";
        p=p->next;  
    }
    cout<<endl;
}
int main(){
    LinkList L;//定义
    //List_TailInsert(L);
    List_HeadInsert(L);
    printList(L);
}

  • 2.3.3双链表

#include <iostream>
#include <cstdlib>
using namespace std;
typedef struct DNode{
    int data;
    struct DNode *prior,*next;
}DNode,*DLinklist;
//初始化
bool InitDLinklist(DLinklist& L){
    L=(DNode*)malloc(sizeof(DNode));
    if(L==NULL)return false;
    L->prior=NULL;
    L->next=NULL;
    return true;
}
//在p节点后插入s节点
bool InsertNextDNode(DNode* p,DNode* s){
    if(p==NULL||s==NULL)return false;
    s->next=p->next;
    if(p->next!=NULL)p->next->prior=s;
    p->next=s;
    s->prior=p;
    return true;
}
//删除p结点的后继结点
bool DeleteNextDNode(DNode* p){
    if(p==NULL)return false;
    DNode* q=p->next;
    if(q->next!=NULL)
        q->next->prior=p;
    free(q);
    return true;
}
//双链表的删除
void DestroyList(DLinklist& L){
    while(L->next!=NULL)
        DeleteNextDNode(L);
    free(L);
    L=NULL;
}
int main(){
    DLinklist L;
    InitDLinklist(L);
    DestroyList(L);
}

  •  2.3.4循环链表

#include <iostream>
#include <cstdlib>
using namespace std;
//循环单链表
typedef struct LNode{
    int data;
    LNode* next;
}LNode,*LinkList;
//初始化循环单链表
bool InitList(Linklist& L){
    L=(LNode*)malloc(sizeof(LNode));
    if(L==NULL)return false;
    L->next=L;
    return true;
}
//判断循环链表是否为空
bool Empty(LinkList& L){
    return (L->next==L);
}
//判断p结点是否为循环单链表的尾结点
bool isTail(LinkList& L,LNode* p){
    return (p->next==L);
}
typedef struct DNode{
    int data;
    DNode *prior,*next;
}DNode,*DLinklist;
//初始化双向循环链表
bool InitDLinklist(DLinklist& L){
    L=(DNode*)malloc(sizeof(DNode));
    if(L==NULL)return false;
    L->prior=L;
    L->next=L;
    return true;
}
//双向循环链表的插入
bool InsertNextNode(DNode* p,DNode* s){
    s->next=p->next;
    p->next->prior=s;
    s->prior=p;
    p->next=s;
}
//删除p的后继结点q
bool DeleteNextDNode(DNode* p){
    DNode* q=p->next;
    p->next=q->next;
    p->next->prior=p;
    free(q);
    return true;
}

  • 2.3.5静态链表

#include <iostream>
#include <cstdlib>
using namespace std;
#define Maxsize 100

typedef struct LNode {
    int data;
    int next;
} LinkList[Maxsize];

// 初始化链表
void InitList(LinkList &L) {
    L[0].next = -1; // 头节点的next设置为-1，表示链表为空
    for (int i = 1; i < Maxsize; i++) {
        L[i].next = -2; // 使用-2表示该位置是空闲的
    }
}

// 在链表的第i个位置插入元素e
bool ListInsert(LinkList &L, int i, int e) {
    if (i < 1 || i >= Maxsize) return false; // 检查插入位置的合法性
    int j = 0;
    // 查找第i-1个位置
    for (int k = 1; k < i; k++) {
        j = L[j].next;
        if (j == -1) return false; // 如果已经到达链表末尾
    }
    // 查找空闲位置
    int free = 1;
    while (L[free].next != -2 && free < Maxsize) free++;
    if (free == Maxsize) return false; // 没有空闲位置
    L[free].data = e;
    L[free].next = L[j].next;
    L[j].next = free;
    return true;
}

// 删除链表的第i个元素
bool ListDelete(LinkList &L, int i) {
    if (i < 1 || i >= Maxsize) return false;
    int j = 0;
    // 查找第i-1个位置
    for (int k = 1; k < i; k++) {
        j = L[j].next;
        if (L[j].next == -1) return false; // 如果已经到达链表末尾
    }
    int toDelete = L[j].next;
    if (toDelete == -1) return false; // 没有元素可以删除
    L[j].next = L[toDelete].next;
    L[toDelete].next = -2; // 将删除的位置标记为空闲
    return true;
}
// 打印链表所有元素
void PrintList(LinkList &L) {
    int j = L[0].next; // 从头节点开始
    while (j != -1) {
        cout << L[j].data << " ";
        j = L[j].next;
    }
    cout << endl;
}

int main() {
    LinkList L;
    InitList(L);
    ListInsert(L, 1, 10);
    ListInsert(L, 2, 20); 
    ListInsert(L, 3, 5);
    ListInsert(L, 2, 90);
    ListInsert(L, 2, 17);
    cout << "After insertions: ";
    PrintList(L); // 打印插入后的链表
    ListDelete(L, 1); // 删除链表第1个位置的元素
    cout << "After deletion: ";
    PrintList(L); // 打印删除后的链表

    return 0;
}

z君埋了吧
关注
专栏目录
考研系列-数据结构第二章、线性表
Nelson_hehe的博客
06-09 1975
本文是408考研付费专栏系列-数据结构线性表章节，本文章详细地总结了线性表的相关知识，其中包括：顺序表、链表（单链表、双链表、循环链表、静态链表等）的细节和重要知识点汇总。考研听课、复习的好帮手。
数据结构笔记（王道考研） 第二章：线性表
zimuzi2019的博客
08-09 2560
数据结构笔记（王道考研） 第二章：线性表
【王道数据结构】第二章 线性表
weixin_48434658的博客
07-16 648
线性表(LinearList)的定义线性表的基本操作什么时候要传入参数的引用**“&”**——对参数的修改结果需要“带回来”顺序表的实现——静态分布顺序表的实现——动态分配顺序表特点什么是单链表用代码定义一个单链表🎈结点的表示即后可写为🎈定义一个单链表获取第i位结点（带头结点）两种实现方式🎨不带头结点🎨带头结点🎨不带头结点V.S.带头结点。...
数据结构 第二章：线性表【笔记】
weixin_56914724的博客
06-26 751
学习王道数据结构第二章线性表整理的笔记
王道数据结构 | 第二章 线性表
emmm_Yeah的博客
07-31 779
王道数据结构整理 第二章线性表 顺序表 单链表 双链表 循环单/双链表 静态链表
考研数据结构--第二章：线性表
蒟蒻
01-03 3622
还在更新中~~ 文章目录线性表线性表的定义线性表的特点 线性表 线性表的定义 线性表是具有相同数据类型的n(n≥0)n(n\ge0)n(n≥0)个元素的有限序列，其中nnn为表长，当n=0n=0n=0时，该表为空表。 aia_iai​是线性表中的“第iii个”元素线性表中的位序。 a1a_1a1​是表头元素；ana_nan​是表尾元素。 除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继。 线性表的特点 表中元素个数有限。 表中元素具有逻辑上的顺序性，在序列中
王道408数据结构——第二章 线性表
weixin_45668903的博客
09-25 1963
文章目录一、线性表的定义和基本操作线性表顺序表1.插入操作2.删除操作3.按值查找（顺序查找）二、单链表1. 头插法2. 尾插法3. 按序号查找4. 按值查找5. 插入结点6. 删除结点7. 求表长三、 双链表1. 插入2. 删除四、循环链表五、静态链表六、顺序表和链表的比较 一、线性表的定义和基本操作 线性表 线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长，n=0是为一个空表。除第一个元素外，每一个元素有且仅有一个直接前驱，除最后一个元素外，每一个元素有且仅有一个直接后驱。 顺序表 线性表
王道数据结构第二章 线性表
weixin_74776795的博客
09-17 141
线性表是具有相同数据类型的n（n>=0)个元素的有限序列，其中n为表长，当n=0时，线性表是一个空表。若用L命名线性表，则其一般表示为ai是线性表中第“i"个元素在线性表中的次序。a1是表头元素，an是表尾元素。位序从1开始，数组下标从0开始。除第一个元素之外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继。由于数据类型相同，所以数据元素所占空间一样大，我们可以方便找到每一个数据元素位置。顺序表：用顺序存储的方式实现线性表把。
2022王道数据结构——第二章线性表代码
qq_43718758的博客
11-05 358
2022王道数据结构——第二章线性表代码2.2顺序表的顺序表示——代码（课后习题）使用的数据结构4.有序顺序表中删除其值在给定值s与t之间（包含s，t）的所有元素，若不合理（st）或表为空显示出错并退出5.顺序表中删除其值在给定值s与t之间（包含s，t）的所有元素，若不合理（st）或表为空显示出错并退出6.有序顺序表中删除删除所有其值重复的元素标准代码7.两个有序顺序表合并一个新的有序顺序表，函数返回结果顺序表8.一维数组里两个线性表，A【m+n】，互换位置书中的代码（reverse函数不同，个人感觉书中的
王道第二章 -线性表的操作
07-16
线性表是数据结构中的基础概念，它是一个包含相同数据类型的有限序列，具有明确的前后顺序。线性表的特点包括：表长n大于等于0，空表时n为0；每个元素除了第一个之外都有唯一的直接前驱，除了最后一个之外都有唯一的...
(王道408考研数据结构)第二章线性表-第一节：线性表的定义和基本操作
快乐江湖的博客
11-07 2908
文章目录一：线性表的定义二：线性表的基本操作 一：线性表的定义 线性表(Linear List)：零个或多个数据元素的有限序列 元素之间是有顺序的 若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他元素都有且只有一个前驱和后继 线性表强调有限，“所有的整数按递增次序排列”很明显不是线性表 线性表可以表示为 L=(a1,a1,...,ai+1,...,an)L=(a_{1},a_{1},...,a_{i+1},...,a_{n})L=(a1​,a1​,...,ai+1​,...,an​) a
考研数据结构————第二章：线性表
Belief的博客
07-24 3943
2021考研的第二章：线性表！！！冲冲冲 文章目录第二章 线性表2.1 线性表的定义和基本操作2.1.1 线性表的定义2.1.2 线性表的基本操作2.2 线性表的顺序表示2.2.1 顺序表的定义2.2.2 顺序表上基本操作的实现2.2.3本章习题 第二章 线性表 【考纲的内容】 （一）线性表的定义和基本操作 （二）线性表的实现 （三）顺序存储：链式存储；线性表的应用 【知识框架】 2.1 线性表的定义和基本操作 2.1.1 线性表的定义 线性表是具有相同数据类型的n(你>=0)个数
【数据结构初阶】排序算法(中)快速排序专题
fhvyxyci的博客
09-28 1190
1. 快排主框架 2. 快排的不同实现 2. 1 hoare版本 2. 2 挖坑法 2. 3 lomuto前后指针法 2. 4 快排的非递归版本 3. 快排优化 3. 1 快排性能的关键点分析: 3. 1 三路划分 3. 2 introsort自省排序
C~排序算法
weixin_60461563的博客
09-27 1108
在C/C++中，有多种排序算法可供选择，每种算法都有其特定的应用场景和特点。下面介绍几种常用的排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序，并给出相应的示例代码和解释。
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 143
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
数据结构-4.2.串的定义和基本操作
最新发布
ADCvbV的博客
10-01 227
1.单/双引号不是字符串里的内容，他只是一个边界符，用来表示字符串的头和尾；2.空串也是字符串的子串，空串长度为0；3.字符的编号是从1开始，不是0；4.空格也是字符；
动态顺序表的增删改查（数据结构）
m0_62048999的博客
09-28 1099
顺序表是数据结构的基础知识，通过学习次内容，可以让我们了解顺序表中数据中是如何进行存储，删除，插入数据的。
数据结构讲解二叉树 【一】
2401_85388078的博客
09-25 1190
在数据结构中，二叉树作为步入实现复杂结构的门栏，为后续的图，排序衔接紧密，因此我将详细讲解二叉树，初定分为三至五篇文章讲解。文章干货满满，还请您细细品读，如果您觉得作者写得不错，抑或对您有所帮助，不妨给俺点个免费的赞和玩玩呢？关注作者不迷路，后续将有更多原创内容更新哟点点点点点点点点点点点点。
数据结构第二章：线性表详解
本PPT详细讲解了计算机科学与技术专业中的核心课程——数据结构的第二章内容，即线性表。线性表是一种基本且重要的数据结构，它由一个有序的数据元素集合组成，每个元素在集合中都有唯一的前后关系。 线性表的四个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值