C语言：带头结点的单链表的表示与实现（包含常见的14种基本操作）

最新推荐文章于 2023-08-16 11:35:25 发布
最新推荐文章于 2023-08-16 11:35:25 发布
阅读量367 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： c语言 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71709382/article/details/131830476
版权

完整代码：

#include <stdio.h>
#include <stdlib.h>
//函数结果状态代码
#define TRUE         1
#define FALSE        0
#define OK           1
#define ERROR        0
#define INFEASIBLE  -1
#define OVERFLOW    -2

//给int定义别名为status，当函数返回值是为状态码时，可用status作为函数类型，更方便理解
typedef int Status;

//定义单链表的结构体
typedef struct LNode
{
    int data;//单链表所存储的值
    struct LNode *next;//指针指向下一个结点
}LNode,*LinkList;//LNode *强调是一共结点，LinkList强调是一个单链表

//初始化一个空的，带头结点的单链表
Status InitList(LinkList *L);

//判断单链表是否为空
Status IsEmptyList(LinkList L);

//销毁单链表
Status DestroyList(LinkList *L);

//清空单链表
Status ClearList(LinkList L);

//求单链表表长,返回值为表长
int LengthList(LinkList L);

//头插法建立单链表，创建n个元素
Status CreateHeadList(LinkList *L,int n);

//尾插法建立单链表，创建n个元素
Status CreateTailList(LinkList *L,int n);

//获取第i个数据元素,并存入e中
Status GetElemList(LinkList L,int i,int *e);

//在单链表第i个位置前插入元素e
Status InsertList(LinkList L,int i,int e);

//按值查找数据所在地址并返回所查询数据的地址
LinkList SearchList(LinkList L,int e);

//按值查找数据所在位序并返回
int LocateList(LinkList L,int e);

//删除在链表中位序为i的结点
Status DeleteList(LinkList L,int i);

//遍历打印单链表数据6
void PrintList(LinkList L);

//合并两个有序链表A,B为一个有序链表C
Status MergeList(LinkList A,LinkList B,LinkList *C);

int main(){
    LinkList L;
    LinkList L1;
    printf("%d\n",InitList(&L));
    printf("%d\n",IsEmptyList(L));
    // CreateHeadList(&L1,4);//头插法
    CreateTailList(&L1,6);//尾插法
    printf("表长为%d\n",LengthList(L1));
    PrintList(L1);
    int e;
    GetElemList(L1,2,&e);
    printf("你所查找的元素为%d\n",e);
    InsertList(L1,1,6);//添加一个结点
    printf("你查找元素的地址为%p\n",SearchList(L1,3));
    printf("你查找元素的位序为%d\n",LocateList(L1,3));
    DeleteList(L1,6);//删除一个结点
    PrintList(L1);
    printf("%d\n",IsEmptyList(L1));
    ClearList(L1);
    PrintList(L1);
    DestroyList(&L1);
    printf("-----------\n");
    printf("-----------\n");
    printf("-----------\n");
    //测试合并函数功能
    LinkList A,B,C;
    InitList(&C);
    CreateTailList(&A,4);
    CreateTailList(&B,4);
    MergeList(A,B,&C);
    printf("合并后的链表C为");
    PrintList(C);
    return 0;
}
//初始化一个空的，带头结点的单链表
Status InitList(LinkList *L){
    *L=(LNode *)malloc(sizeof(LNode));//分配一个头结点
    if (*L==NULL)
    {
        printf("分配内存失败\n");
        exit(OVERFLOW);
    }
    (*L)->next=NULL;//将头节点的后继置空
    return OK;
}
//判断单链表是否为空
Status IsEmptyList(LinkList L){
    //只需判断头节点是否有后继
    if (L->next==NULL)
    {
        printf("当前单链表为空\n");
        return TRUE;
    }
    else
    {
        printf("当前单链表不为空\n");
        return FALSE;
    }
}
//销毁单链表
Status DestroyList(LinkList *L){
    LinkList p=*L;
    //free所有的结点包括头结点
    while (*L)
    {
        *L=(*L)->next;
        free(p);
        p=*L;
    }
    printf("链表已销毁\n");
    return OK;
}
//清空单链表
Status ClearList(LinkList L){
    //free所有结点，不包括头结点
    LinkList p,q;
    p=L->next;
    //p为NULL时说明链表已经全部清空
    while (p)
    {
        q=p->next;
        free(p);
        p=q;
    }
    //头结点指向NULL，此时链表为空表
    L->next=NULL;
    printf("链表已清空\n");
    return OK;
}
//求单链表表长,返回值为表长
int LengthList(LinkList L){
    LinkList p;
    int count=0;//记录表长
    p=L->next;
    while (p)
    {
        count++;
        p=p->next;
    }
    return count;
}
//头插法建立单链表，创建n个元素
Status CreateHeadList(LinkList *L,int n){
    LinkList p,r;//p指向新结点，r指向头节点
    *L=(LinkList)malloc(sizeof(LNode));//创建头结点
    if (*L==NULL)
    {
        printf("分配内存失败\n");
        exit(OVERFLOW);
    }
    r=*L;
    r->next=NULL;//避免脏数据
    for (int i = n; i >0; i--)
    {
        p=(LNode *)malloc(sizeof(LNode));//生成新的结点
        printf("请输入链表的第%d个元素\n",i);
        scanf("%d",&p->data);
        //插入到表头
        p->next=NULL;//避免脏数据
        p->next=r->next;
        r->next=p;
    }
    printf("创建完毕\n");
    return OK;
}
//尾插法建立单链表，创建n个元素
Status CreateTailList(LinkList *L,int n){
    LinkList p,r;//p指向新结点,r指向链表尾部结点
    *L=(LinkList)malloc(sizeof(LNode));//创建头结点
    if (*L==NULL)
    {
        printf("分配内存失败\n");
        exit(OVERFLOW);
    }
    r=*L;
    r->next=NULL;
    for (int i = 0; i <n; i++)
    {
        p=(LinkList)malloc(sizeof(LNode));//生成新的结点
        if (!p)
        {
            printf("分配内存失败\n");
            exit(OVERFLOW);
        }
        printf("请输入链表的第%d个元素\n",i+1);
        scanf("%d",&p->data);
        //插入到表头
        p->next=NULL;//避免脏数据
        r->next=p;
        r=r->next;//将尾部指针移向新的结点p，然后p就变成新的尾部结点
    }
    r->next=NULL;
    printf("创建完毕\n");
    return OK;

}
//获取第i个数据元素,并存入e中
Status GetElemList(LinkList L,int i,int *e){
    LNode *p;
    p=L->next;
    int j=1;
    //通过循环到达第i个元素
    while (p&&j<i)
    {
        p=p->next;
        j++;
    }
    //当i不合法时不能查询
    if (!p||j>i){
        printf("查询不到该元素\n");
        return ERROR;
    }
    *e=p->data;
    return OK;
}
//在单链表第i个位置前插入元素e
Status InsertList(LinkList L,int i,int e){
    LinkList p,s;
    p=L;//指向头结点
    s=(LNode *)malloc(sizeof(LNode));//建立要插入的结点
    if (!s)
    {
        printf("分配内存失败\n");
        exit(OVERFLOW);
    }
    s->data=e;
    s->next=NULL;
    int j=0;
    //通过循环到达第i-1个元素
    while (p&&j<i-1)
    {
        p=p->next;
        j++;
    }
    if(!p||j>i-1) return ERROR;//当i不合法时不能插入
    s->next=p->next;
    p->next=s;
    printf("插入元素成功\n");
    return OK;
}
//按值查找数据所在地址并返回所查询数据的地址
LinkList SearchList(LinkList L,int e){
    LNode *p;
    p=L->next;
    while (p)
    {
        if (p->data==e) return p;
        p=p->next;
    }
    printf("没有找到该数据\n");
    return NULL;
}
//按值查找数据所在位序并返回
int LocateList(LinkList L,int e){
    LNode *p;
    int j=1;
    p=L->next;
    while (p)
    {
        if (p->data==e) return j;
        p=p->next;
        j++;
    }
    printf("没有找到该数据\n");
    return ERROR;
}
//删除在链表中位序为i的结点
Status DeleteList(LinkList L,int i){
    LinkList p,q;
    p=L;
    //让p到达位序为i-1处
    for (int j = 0; p&&j < i-1; j++)
    {
        p=p->next;
    }
    q=p->next;//q为被删除的结点
    if (!q)
    {
        printf("i的值不合法\n");
        return ERROR;
    }
    p->next=q->next;
    free(q);
    printf("删除成功\n");
    return OK;
}
//遍历打印单链表数据
void PrintList(LinkList L){
    LinkList p=L->next;
    if (!p)
    {
        printf("链表为空,无法打印\n");
        
    }else{
    printf("单链表为Head");
    }
    while (p)
    {
        printf("->%d",p->data);
        p=p->next;
    }
    printf("\n");
}
//合并两个有序链表A,B为一个有序链表C
Status MergeList(LinkList A, LinkList B, LinkList *C) {
    LNode *pa;
    LNode *pb;
    LNode *pc;
    pa = A->next;
    pb = B->next;
    pc =*C;//pc为遍历和操作链表 C 的指针
    while (pa && pb) {
        if (pa->data <= pb->data) {
            pc->next = pa;
            pc = pc->next;
            pa = pa->next;
        } else {
            pc->next = pb;
            pc = pc->next;
            pb = pb->next;
        }
    }
    //插入剩余段
    if (pa != NULL) pc->next = pa;
    if (pb != NULL) pc->next = pb;
    free(B);
    printf("合并成功\n");
    return OK;
}

运行截图：

 

 

C PLUS+
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构：C语言实现----带头结点的单链表
kimEHEH的博客
08-12 1011
带头结点的单链表 特点： ①头结点定义在栈区，不保存数据，起标记作用，不参与具体运算。 ②其他数据结点在堆区，动态申请内存/ 带头结点的单链表结构体声明 typedef struct Node { int data; struct Node *next; }Node, *LinkList; （1）初始化：头结点本身已存在，只需将头的next置为NULL void InitLinkList(LinkList plist) { assert(plist != NULL); if(plist == NU
单链表的基本操作(C++链表实现)
qq_35814058的博客
04-10 3313
[问题描述] 实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。 [基本要求] （1）依次从键盘读入数据，建立带头结点的单链表； (2）输出单链表中的数据元素 （3）求单链表的长度； （4）根据指定条件能够取元素和修改元素； （5）实现在指定位置插入和删除元素的功能 1、初始化链表输入0停止输入： void init(LinkList &L) { LinkList p = new LNode; L = new LNode; L-&gt..
链表-使用C语言实现带头结点的单链表.zip
最新发布
03-13
链表 链表_使用C语言实现带头结点的单链表
带头结点的单链表实现（C语言）
qq_44812831的博客
06-24 255
【代码】带头结点的单链表实现（C语言）
【数据结构】C语言实现单链表（带头结点）
SHLYYY
05-04 1893
SLLWNode;// 在pos之前插入 void SLLWInsert(SLLWNode * phead , SLLWNode * pos , SLLWDataType x);// 在pos之后插入 void SLLWInsertAfter(SLLWNode * pos , SLLWDataType x);// 删除pos位置的值 void SLLWErase(SLLWNode * phead , SLLWNode * pos);
PTA 6-8 求单链表表长 (10 分)本题要求实现一个函数，Length_LinkList(LinkList L)函数是求出带头结点单链表的长度。
m0_61049596的博客
03-25 2538
6-8 求单链表表长 (10 分) 本题要求实现一个函数，Length_LinkList(LinkList L)函数是求出带头结点单链表的长度。 函数接口定义： int Length_LinkList(LinkList L); 其中L是用户传入的参数。L是单链表的头指针。函数须返回单链表的长度。 裁判测试程序样例： #define FLAG -1 #include <stdio.h> #include <malloc.h> typedef int da...
带头结点单链表的基本操作
edceee的博客
08-16 113
带头结点单链表的基本操作。
带头结点的链表的创建与使用
m0_74114068的博客
03-07 203
以下描述了带头结点链表的插入，删除，查找等功能的实现
C语言实现单链表（带头结点）的基本操作
10-09
C语言实现单链表（带头结点）的基本操作 C语言实现单链表（带头结点）的基本操作 C语言实现单链表（带头结点）的基本操作 C语言实现单链表（带头结点）的基本操作
C语言实现单链表（带头结点）的基本操作.zip
02-28
C语言实现单链表（带头结点）的基本操作.zip
单链表的创建，查找，插入，删除、长度
qq_46093754的博客
07-19 1875
单链表线性表的链式存储，通过任意的存储单元来存储线性表中的数据元素。优点不需要大片的连续的空间，改变容量方便。缺点不可随机读取，要耗费一定空间存放指针。
数据结构--带头结点的单向链表
散步的呆头鹅的博客
08-05 2115
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。
用C语言实现单链表操作
xuzhougeng blog
02-02 6570
用C写一个链表 链表(Linked List)是一种非连续的线性数据结构，相对于数组，它允许数据在内存中非连续存储，但是不支持随机读取。 链表 链表由一个个节点(Node)组成，每个节点除了记录数据以外，还需要记录下一个节点的位置（如果是双向链表，还需要记录上一个节点的位置） struct _Node; typedef struct _Node Node; struc...
数据结构实验一（1）
a201808064823的博客
09-18 1443
题目一：线性表的顺序表示 [问题描述] 实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。 [基本要求] （1）依次从键盘读入数据，建立带头结点的单链表； （2）输出单链表中的数据元素； （3）求单链表的长度； （4）根据指定条件能够取元素和修改元素； （5）实现在指定位置插入和删除元素的功能。 [源代码]（加注释） #inclu...
C语言实现单链表的一些操作详细说明（带头指针）
ck8719的博客
05-24 2075
关于头节点与头指针的一些说明 头指针：链表中第一个结点的存储位置就叫做头指针 在实现链表操作时，有两种方法去实现：一种是带头结点的，一种是不带头结点的，即只有头指针的情况。 针对于第一种： 这种情况下，头指针是指向头结点的，而头结点才指向我们的首结点，即真正我们要插入的结点。 头结点的数据域一般是不存任何数据的，但是也可以存储链表的长度之类的。 有了头结点后，对在第一个元素结点前插入结点和删除第一个结点，其操作与对其它结点的操作统一了。 针对于第二种情况 对于这种情况，我们的头指针就直接指向了我们要插入的
使用C语言实现单链表的功能（带头节点）
Keep_Trying_Go的博客
08-06 867
使用C语言实现单链表的功能（带头节点）
C语言链表完整实现（带头节点）
weixin_33908217的博客
12-07 109
#include <stdio.h> #include <stdlib.h> #define ElementType int typedef struct LNode *PtrToNode; struct LNode { ElementType Data; PtrToNode Next; }; typedef PtrToNode List; ...
带头结点的单链表操作（头插法）-c语言实现
weixin_30878361的博客
05-05 1196
c语言编写 带头结点的单链表操作（头插法） #include<stdio.h> #include<stdlib.h> #include<conio.h> typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; ...
单链表C语言
ProgramVAE的博客
12-19 337
seqlist.h #ifndef _SEQLIST_H #define _SEQLIST_H #include"ututli.h" #define ElemType int #define DEFAULT_SIZE 8 //初始化时数组的长度 #define LIST_INCREMENT 2 //每次增加的长度 typedef struct SeqList { ElemType *b
C语言实现带头结点的单链表的结点值按升序排列
03-28
以下是C语言实现带头结点的单链表的结点值按升序排列的代码： ```c #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node *next; } Node, *LinkedList; LinkedList createLinkedList(int n); void sortLinkedList(LinkedList head); void printLinkedList(LinkedList head); int main() { int n; printf("Enter the number of nodes: "); scanf("%d", &n); LinkedList head = createLinkedList(n); printf("Original linked list: "); printLinkedList(head); sortLinkedList(head); printf("Sorted linked list: "); printLinkedList(head); return 0; } LinkedList createLinkedList(int n) { LinkedList head = (LinkedList) malloc(sizeof(Node)); head->next = NULL; LinkedList tail = head; for (int i = 0; i < n; i++) { int data; printf("Enter the value of node %d: ", i + 1); scanf("%d", &data); LinkedList new_node = (LinkedList) malloc(sizeof(Node)); new_node->data = data; new_node->next = NULL; tail->next = new_node; tail = new_node; } return head; } void sortLinkedList(LinkedList head) { if (head->next == NULL || head->next->next == NULL) { return; } LinkedList p = head->next; head->next = NULL; while (p != NULL) { LinkedList q = p->next; LinkedList prev = head; while (prev->next != NULL && prev->next->data < p->data) { prev = prev->next; } p->next = prev->next; prev->next = p; p = q; } } void printLinkedList(LinkedList head) { LinkedList p = head->next; while (p != NULL) { printf("%d ", p->data); p = p->next; } printf("\n"); } ``` 该代码首先定义了一个`Node`结构体，包含了一个整数数据域和一个指向下一个结点的指针。然后定义了一个`LinkedList`类型，为指向结点的指针。接着定义了三个函数：`createLinkedList`用于创建一个带头结点的单链表，`sortLinkedList`用于将单链表中的结点值按升序排列，`printLinkedList`用于打印单链表中的所有结点的值。 在`main`函数中，首先让用户输入需要创建的单链表的结点个数`n`，然后调用`createLinkedList`函数创建一个带头结点的单链表。接着打印原始单链表，调用`sortLinkedList`函数将单链表中的结点值按升序排列，再次打印排好序后的单链表。最后返回0表示程序正常结束。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值