顺序表+单向链表

最新推荐文章于 2024-06-29 14:51:47 发布
最新推荐文章于 2024-06-29 14:51:47 发布
阅读量78 收藏
点赞数
文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61448242/article/details/131040903
版权

1.顺序表

#include <stdio.h>
#include <stdlib.h>
#define N 10

typedef struct
{
    int data[N];
    int last;//last代表的是数组中最后一个有效元素的下标
}seqlist_t;

//1.创建一个空的顺序表
seqlist_t* CreateEpSeqlist();//返回的是申请空间的首地址

//2.向顺序表的指定位置插入数据
int InsertIntoSeqlist(seqlist_t* p, int post, int data);//post第几个位置，data插入的数据

//3.遍历顺序表sequence 顺序 list 表
void ShowSeqlist(seqlist_t* p);

//4.判断顺序表是否为满,满返回１ 未满返回０
int IsFullSeqlist(seqlist_t* p);

//5.判断顺序表是否为空
int IsEpSeqlist(seqlist_t* p);

//6.删除顺序表中指定位置的数据post删除位置
int DeletePostSeqlist(seqlist_t* p, int post);

//7.清空顺序表
void ClearSeqList(seqlist_t* p);

//8.修改指定位置的数据
void ChangePostSeqList(seqlist_t* p, int post, int data);//post被修改的位置，data修改成的数据

//9.查找指定数据出现的位置
int SearchDataSeqList(seqlist_t* p, int data);//data代表被查找的数据

//10.合并表
void CombineAB(seqlist_t *p,seqlist_t *pb);

int main()
{
    seqlist_t* p = CreateEpSeqlist();//创建一个空的顺序表
    InsertIntoSeqlist(p, 0, 1);
    InsertIntoSeqlist(p, 1, 2);
    InsertIntoSeqlist(p, 2, 3);
    InsertIntoSeqlist(p, 3, 4);
    ShowSeqlist(p);//1 2 3 4
    DeletePostSeqlist(p, 1);
    ShowSeqlist(p);//1 3 4
    ChangePostSeqList(p, 1, 100);
    ShowSeqlist(p);//1 100 4
    int t;//承接查找数据的下标
    t=SearchDataSeqList(p, 4);
    printf("4 post is %d\n", t);//1
//    ShowSeqlist(p);
//      ClearSeqList(p);
//    ShowSeqlist(p);

    seqlist_t* pb = CreateEpSeqlist();
    InsertIntoSeqlist(pb, 0, 1);
    InsertIntoSeqlist(pb, 1, 100);
    InsertIntoSeqlist(pb, 2, 200);
    InsertIntoSeqlist(pb, 3, 300);
    InsertIntoSeqlist(pb, 4, 400);
    InsertIntoSeqlist(pb, 5, 500);
        InsertIntoSeqlist(pb, 6, 600);
//        InsertIntoSeqlist(pb, 7, 700);
//        InsertIntoSeqlist(pb, 8, 800);
//        InsertIntoSeqlist(pb, 9, 900);
    ShowSeqlist(pb);
    CombineAB(p,pb);
    ShowSeqlist(p);
    return 0;
}

//1.创建一个空的顺序表
seqlist_t* CreateEpSeqlist()//返回的是申请空间的首地址
{
    //动态申请一块空间
    seqlist_t* p = (seqlist_t*)malloc(sizeof(seqlist_t));
    //sizeof(seqlist_t)计算结构体的大小
    if (p == NULL) {
        printf("申请空顺序表错误\n");
        return NULL;
    }
    //last是最后一个有效元素的下标
    p->last = -1;//空
    return p;
}

//4.判断顺序表是否为满,满返回１ 未满返回０
int IsFullSeqlist(seqlist_t* p)
{
    return p->last+1== N;//成立返回1（满），不成立返回0
}

//2.向顺序表的指定位置插入数据
int InsertIntoSeqlist(seqlist_t* p, int post, int data)//post第几个位置，data插入的数据
{
    //1、容错判断
    //小于最小，大于最大；顺序表满了帮你插入
    if (post<0 || post>p->last+1|| IsFullSeqlist(p)) {
        printf("插入失败\n");
        return -1;//错误返回
    }
    //2、last-post往后移动一个位置
    int i;
    for (i = p->last;i>=post; i--) {
        p->data[i+1] = p->data[i];
    }
    //3、插入数据
    p->data[post] = data;
    //4、p->last+1
    p->last++;
    return 0;
}

//3.遍历顺序表sequence 顺序 list 表
void ShowSeqlist(seqlist_t* p)
{
    int i;
    for (i = 0; i <= p->last; i++) {
        printf("%d ", p->data[i]);
    }
    printf("\n");
}

//5.判断顺序表是否为空
int IsEpSeqlist(seqlist_t* p)
{
    return p->last == -1;
}

//6.删除顺序表中指定位置的数据post删除位置
int DeletePostSeqlist(seqlist_t* p, int post)
{
    //1、容错判断
    if (post > p->last || post < 0 || IsEpSeqlist(p)) {
        printf("删除失败\n");
        return -1;
    }
    //2、post+1-last向前移动一个位置
    int i;
    for (i = post + 1; i <= p->last; i++) {
        p->data[i - 1] = p->data[i];
    }
    //3、有效元素-1
    p->last--;
    return 0;
}

//7.清空顺序表（清空：访问不到，但内存当中还有;销毁：内存清空）
void ClearSeqList(seqlist_t* p)
{
    p->last = -1;
}

//8.修改指定位置的数据
void ChangePostSeqList(seqlist_t* p, int post, int data)//post被修改的位置，data修改成的数据
{
    //1、容错判断
    if (post<0 || post>p->last) {
        printf("修改失败\n");
    }
    //2、修改指定位置数据
    p->data[post] = data;
}

//9.查找指定数据出现的位置
int SearchDataSeqList(seqlist_t* p, int data)//data代表被查找的数据
{
    int i;
    for (i = 0; i <= p->last; i++) {
        if (p->data[i] == data) {
            return i;
        }
    }
    return -1;
}
//10.合并表
void CombineAB(seqlist_t *p,seqlist_t *pb)
{
    int i;
    for(i=0;i<=pb->last;i++){
    if(SearchDataSeqList(p,pb->data[i])==-1){//没有找到
    InsertIntoSeqlist(p,p->last+1,pb->data[i]);
        }
    }
}

链表

 

#include <stdio.h>
#include <stdlib.h>
typedef int datatype; //datatype是数据的类型，这里写的int那就是int类型，
//后面如果想传参都用datatype，如果想用char就把int换成char，接下来只用改输入输出的格式，其他的都不用改
typedef struct node_t
{
    datatype data;//数据域
    struct node_t* next;//指针域,指向自身结构体的指针
}link_node_t, * link_list_t;
//1.创建一个空的单向链表(有头单向链表)
link_node_t* CreateEpLinkList();
//2.向单向链表的指定位置插入数据
//p保存链表的头指针 post 插入的位置 data插入的数据
int InsertIntoPostLinkList(link_node_t* p, int post, datatype data);
//3.遍历单向链表
void ShowLinkList(link_node_t* p);
//4.求单向链表长度的函数
int LengthLinkList(link_node_t* p);
//5.删除单向链表中指定位置的数据 post 代表的是删除的位置
int DeletePostLinkList(link_node_t* p, int post);
//6.判断单向链表是否为空 1代表空 0代表非空
int IsEpLinkList(link_node_t* p);
//7.修改指定位置的数据 post 被修改的位置 data修改成的数据
int ChangePostLinkList(link_node_t* p, int post, datatype data);
//8.查找指定数据出现的位置 data被查找的数据 //search 查找
int SearchDataLinkList(link_node_t* p, datatype data);
//9.删除单向链表中出现的指定数据,data代表将单向链表中出现的所有data数据删除
int DeleteDataLinkList(link_node_t* p, datatype data);
//10.转置链表
void ReverseLinkList(link_node_t* p);
//11.清空单向链表
void ClearLinkList(link_node_t* p);

int main()
{
    link_list_t p = CreateEpLinkList();
    InsertIntoPostLinkList(p, 0, 1);
    InsertIntoPostLinkList(p, 1, 2);
    InsertIntoPostLinkList(p, 2, 3);
    InsertIntoPostLinkList(p, 3, 4);
    InsertIntoPostLinkList(p, 4, 5);
        InsertIntoPostLinkList(p, 5, 6);
    InsertIntoPostLinkList(p, 6, 7);
    ShowLinkList(p);//1 2 3 4 5

    DeletePostLinkList(p, 1);
    ShowLinkList(p);//1 3 4 5
        
    ChangePostLinkList(p, 1, 100);
    ShowLinkList(p);

        int post;
    post=SearchDataLinkList(p, 4);
    printf("4 post is %d\n",post);
        
    DeleteDataLinkList(p, 4);
        ShowLinkList(p);
        
        ReverseLinkList(p);
    ShowLinkList(p);

    return 0;
}

//1.创建一个空的单向链表(有头单向链表)
link_node_t* CreateEpLinkList()
{
    //创建节点
    link_list_t p = (link_list_t)malloc(sizeof(link_node_t));
    if (p == NULL)
    {
        printf("error\n");
        return NULL;
    }
    //头节点初始化
    p->next = NULL;
    return p;
}
//4.求单向链表长度的函数(不包含头节点，是实际数据长度)
int LengthLinkList(link_node_t* p)
{
    int len = 0;
    while (p->next != NULL) {
        p = p->next;
        len++;
    }
    return len;
}
//2.向单向链表的指定位置插入数据
//p保存链表的头指针 post 插入的位置 data插入的数据
int InsertIntoPostLinkList(link_node_t* p, int post, datatype data)
{
    //1.容错判断
    if (post<0 || post>LengthLinkList(p)) {
        printf("error\n");
        return -1;
    }
    //2.头指针往后移动，指向插入位置前一个节点
    int i;
    for (i = 0; i < post; i++) {
        p = p->next;
    }
    //3.创建新节点，保存插入数据
    link_list_t pnew = (link_list_t)malloc(sizeof(link_node_t));
    if (pnew == NULL)
    {
        printf("error\n");
        return -1;
    }
    pnew->data = data;
    pnew->next = NULL;
    //4.新节点插入链表，先连后面，再连前面
    pnew->next = p->next;
    p->next=pnew;

    return 0;
}
//3.遍历单向链表
void ShowLinkList(link_node_t* p)
{
    while (p->next != NULL) {
        p = p->next;
        printf("%d ", p->data);
    }
    printf("\n");
}
//6.判断单向链表是否为空 1代表空 0代表非空
int IsEpLinkList(link_node_t* p)
{
    return p->next == NULL;
}
//5.删除单向链表中指定位置的数据 post 代表的是删除的位置
int DeletePostLinkList(link_node_t* p, int post)
{
    //1.容错判断
    if (post < 0 || post >= LengthLinkList(p) || IsEpLinkList(p)) {
        printf("error\n");
        return -1;
    }
    //2.头节点指向被删除节点的前一个位置
    int i;
    for (i = 0; i < post; i++) {
        p = p->next;
    }
    //3.删除
    link_list_t pdel = NULL;
    //(1)定义一个pedl指针指向被删除位置
    pdel = p->next;
    //(2)跨过被删除节点
    p->next = pdel->next;
    //(3)释放被删除节点
    free(pdel);
    pdel = NULL;
    return 0;
}
//11.清空单向链表
void ClearLinkList(link_node_t* p)
{
    link_list_t pdel = NULL;
    //有头的遍历单向链表
    while (p->next != NULL) {
        //（1）pdel指向被删除节点
        pdel = p->next;//每次删除头节点的下一个
        //（2）跨过删除
        p->next = pdel->next;
        //（3）释放
        free(pdel);
        pdel = NULL;
    }
}
//7.修改指定位置的数据 post 被修改的位置 data修改成的数据
int ChangePostLinkList(link_node_t* p, int post, datatype data)
{
    //1.容错判断
    if (post < 0 || post >= LengthLinkList(p)) {
        printf("error\n");
        return -1;
    }
    //2.头指针移动到被修改节点
    int i;
    for (i = 0; i < post + 1; i++) {
        p = p->next;
    }
    //3.修改数据
    p->data = data;
    return 0;
}

//8.查找指定数据出现的位置 data被查找的数据 /arch 查找
int SearchDataLinkList(link_node_t* p, datatype data)
{
    int post = 0;//记录查找位置
    //遍历链表
    while (p->next != NULL)
    {
        //先往前走一个，因为头节点没有数据
        p = p->next;
        if (p->data == data) {
            return post;
        }
        post++;
    }
    //如果遍历玩还没有找到
    return -1;//说明数据不存在
}


//9.删除单向链表中出现的指定数据,data代表将单向链表中出现的所有data数据删除
int DeleteDataLinkList(link_node_t* p, datatype data)
{
    /*
    if (相等) {//删
        pdel = q;
        p->next = pdel->next;
        free(pdel);
        pedl = NULL;
        q = p->next;
    }
    else
    {
        p = p->next;
        q = q->next;
    }
    */
    link_list_t pdel = NULL;//指向被删除节点
    //1.定义q
    link_list_t q = p->next;
    //q来遍历单向无头链表，每个节点data比较
    while (q != NULL) {
        if (q->data == data) {
            pdel = q;
            p->next = pdel->next;
            free(pdel);
            pdel = NULL;
            q = p->next;
        }
        else {
            p = p->next;
            q = q->next;
        }
    }
    return 0;
}
//10.转置链表
//(1) 将头节点与当前链表断开，断开前保存头节点的下一个节点，保证后面链表能找得到，定义一个q保存头节点的下一个节点，断开后前面相当于一个空的链表，后面是一个无头的单向链表
//(2) 遍历无头链表的所有节点，将每一个节点当做新节点插入空链表头节点的下一个节点(每次插入的头节点的下一个节点位置--头插法)
void ReverseLinkList(link_node_t* p)
{
    //定义temp暂时保存后面节点
    link_list_t temp = NULL;
    //1.断开之前保存头节点下一个节点
    link_list_t q = p->next;
    //2.断开链表
    p->next = NULL;
    //3.遍历无头链表
    while (q != NULL) {
        //提前把q下一个节点保存一下
        temp = q->next;
        //先连后面，再连前面
        q->next = p->next;
        p->next = q;
        //q移动，移动到无头链表下一个节点
        q = temp;
    }
}

 

Star blingbling
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java实现单向链表反转
08-27
Java实现单向链表反转是指将单向链表的顺序颠倒，例如原链表为A->B->C->D->E->F，反转后变为F->E->D->C->B->A。这种操作在实际开发中非常有用，例如在数据处理、数据分析等领域。 单向链表反转的实现方式有两种，一...
6-2 顺序表操作集 (20分)
m0_46168903的博客
03-14 869
本题要求实现顺序表的操作集。 函数接口定义： List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中List结构定义如下： typedef int Positi...
6-2 顺序表操作集（20 point(s)）
热门推荐
codeswarrior的博客
11-02 2万+
6-2 顺序表操作集（20 point(s)） 本题要求实现顺序表的操作集。 函数接口定义： List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P );
Python单向链表和双向链表原理与用法实例详解
09-20
在单向链表中，遍历只能从头节点开始，按顺序访问每个节点，无法反向遍历。下面我们将详细讨论其创建、插入和删除操作： 1. 创建单向链表： 创建单向链表通常需要一个头节点，表示链表的起始位置。在Python中，...
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
C语言之单向链表详解及实例代码
12-31
单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有...
单向链表实现基排序
04-08
单向链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。在计算机科学中，链表常用于构建动态数据结构，因为它们允许高效的插入和删除操作，尤其是在元素的位置未知时。而基...
顺序表--数据结构第一关
Mr_Xuhhh的博客
06-27 593
主要是以C语言的基础上实现顺序表
深入解析链表：解锁数据结构核心奥秘
最新发布
2301_79339087的博客
06-29 1152
链表是一种线性数据结构，由一系列节点组成。数据域（Data）：存储节点的数据。指针域（Pointer）：存储指向下一个节点的地址。链表的第一个节点称为头节点（Head），最后一个节点的指针域指向空（NULL），表示链表的结束。
C语言---数据结构（1）--时间复杂和空间复杂度计算
2301_80863610的博客
06-24 3014
时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要的额外空间，在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。这里就不同了，因为我们使用malloc开辟了一个n+1个元素的空间，原本的变量就有5个，所以总共的变量就是N+6，但是6对结果的影响不大，所以这个题的空间复杂度就是O(N)了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度看的是我们最多的时候占了多少空间，也就是看最坏的情况的时候我们用了最大空间是多少。
数据结构--栈与队列
pzn2506的博客
06-27 386
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out)队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。把队尾前面全部数据给到另一个队列，就能取到队尾相当于栈顶的数据。入队列：进行插入操作的一端称为队尾。出队列：进行删除操作的一端称为队头。：栈的删除操作叫做出栈。栈的实现一般可以使用。
【数据结构】二叉树
一岁就可帅的博客
06-26 825
二叉树是一种树形结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树的根节点是树的起点，其他节点通过根节点及其子节点逐层连接形成树状结构。节点（Node）：二叉树的基本元素，每个节点包含一个数据元素以及指向其左右子节点的指针。根节点（Root Node）：树的起点节点。叶子节点（Leaf Node）：没有子节点的节点。子树（Subtree）：以某个节点为根的树。
数据结构之链表
2203_76059817的博客
06-24 967
数据结构之链表备忘录
005 数据结构
m0_46695127的博客
06-26 449
005 数据结构
【数据结构】使用C语言 从零编写一个顺序表
努力！加油！！
06-25 887
线性表是由同一类型的数据元素构成的有序序列的线性结构。线性表中元素的个数就是线性表的长度，表的起始位置称为表头，表的结束位置称为表尾，当一个线性表中没有元素时，称为空表。由于我们需要设计一个新的数据结构，所以我们提前定义一个该数据结构的结构体。假设该结构体存储的类型是int，把int型起个别名E，如果以后需要存别的类型，就把这个E修改就可以了。这里通过struct声明了一个结构体，其中包括一个E类型的数组，capacity表示该数组的容量。
数据结构之B树
zgy_boke的博客
06-26 283
插入操作：如果插入后节点中的关键字数量超过阶数规定的上限，需要进行节点分裂，将中间的关键字提升到父节点，并将节点分裂为两个。B 树的查找操作类似于二叉查找树，但由于是多路查找，需要在节点内部根据关键字进行比较和判断，然后选择合适的子节点继续查找。B 树（B-Tree）是一种平衡的多路查找树，常用于数据库和文件系统中，以实现对大量数据的高效存储和检索。删除操作：如果删除后节点中的关键字数量过少，可能需要进行节点合并或从兄弟节点借关键字。
数据结构之B+树
zgy_boke的博客
06-26 226
在数据库中，B+树常被用作索引结构。通过 B+树的索引，可以快速定位到数据所在的叶子节点，然后通过叶子节点之间的链表获取所需的数据范围。B+树是一种特殊的 B 树变体，在数据库和文件系统等领域有广泛应用。
排序算法(2)之选择排序----直接选择排序和堆排序
wer24_25的博客
06-26 1030
详细讲解了排序算法(2)之选择排序----冒泡排序和堆排序,简单明了,小白也能轻松看懂
【408考点之数据结构】二叉树的遍历及线索二叉树
gygkhd的博客
06-26 715
二叉树的遍历是指按照一定的顺序访问二叉树中所有节点。常见的遍历方法有前序遍历（Preorder Traversal）、中序遍历（Inorder Traversal）、后序遍历（Postorder Traversal）和层次遍历（Level Order Traversal）。前序遍历（Preorder Traversal）： 中序遍历（Inorder Traversal）： 后序遍历（Postorder Traversal）： 层次遍历（Level Order Traversal）： 二、线索
洛谷b3631+单向链表
09-16
洛谷b3631是一个单向链表的题目。单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含了数据以及指向下一个节点的指针。通过这种方式，链表中的节点可以按照一定的顺序连接起来，形成一个链式结构。在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值