LinkList 单链表的实现

最新推荐文章于 2024-04-17 22:26:15 发布
最新推荐文章于 2024-04-17 22:26:15 发布
阅读量5.3k 收藏 17
点赞数 2
分类专栏： Data Structure 文章标签： 单链表 链表 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuemocheng/article/details/52047918
版权

LinkList.h

#include "stdio.h"
#include "math.h"
#include "malloc.h"
#include "stdlib.h"

//typedef int DataType;

//LinkNode是链表的结点类型，LinkList是指向链表的指针类型
//如果定义了 LinkList L;则定义了一个链表，L指向该链表的第一个结点
//不带头结点，链表为空，L=NULL;带头结点，链表为空，L->next = NULL;
typedef struct Node{
    DataType data;
    struct Node *next;
}LinkNode, *LinkList;


//初始化单链表,将单链表置空
//将单链表初始化为空。动态生成一个头结点，并将头结点的指针域置空
//根据typedef定义，LinkList 就是 ListNode* ，即 ListNode 的指针；
//根据InitList函数的形参声明，head 变量是 LinkList 类型的指针，即 ListNode 的二级指针。
//因此，*head 才是LinkList类型。
void InitList(LinkList *head) 
{
    if ((*head = (LinkList)malloc(sizeof(LinkNode))) == NULL)
        /*为头结点分配一个存储空间*/
        exit(-1);
        /* exit是一个进程，-1表示异常退出,要包含头文件 "stdlib.h" */
    (*head)->next = NULL;
}

//判断单链表是否为空，就是通过判断头结点的 指针域是否为空
//空返回 1 ; 否则返回 0;
int ListEmpty(LinkList head) 
{
    if (head->next == NULL)
        return 1;
    else
        return 0;
}

//按序号查找操作
//查找单链表中第i个结点。查找成功返回该结点的指针，否则返回NULL标志失败
LinkNode* Get(LinkList head, int i) {
    LinkNode *p;
    int j;
    if (ListEmpty(head))    //不为 0 表示链表为空
        return NULL;
    if (i < 1)              //判断序号是否合法
        return NULL;        
    j = 0;
    p = head;
    while (p->next != NULL && j < i) 
    {
        p = p->next;
        j++;
    }
    if (j == i) 
        return p;          //找到第 i 个结点，返回指针p;
    else
        return NULL;       //如果没找到第 i 个元素，返回NULL;
}


//按内容查找操作
//查找线性表中元素值为 e 的元素
//成功返回对应元素的结点的指针；否则返回NULL，表示失败
LinkNode* LocateElem(LinkList head, DataType e) 
{
    LinkNode* p;
    p = head->next;        //指针p指向第一个结点
    while (p)
    {
        if (p->data != e)
            p = p->next;
        else
            break;
    }
    return p;
}


//定位操作
//按内容查找并返回该结点的序号，称为定位函数
//查找线性表中元素值为 e 的元素，成功返回对应元素的序号，否则返回0;
int LocatePos(LinkList head, DataType e) 
{
    LinkNode* p;
    int i;
    if (ListEmpty(head))  //先判断链表是否为空
        return 0;
    p = head->next;      //指针p指向第一个结点
    i = 1;
    while (p) 
    {
        if (p->data == e)
            return i;
        else 
        {
            p = p->next;
            i++;
        }
    }
    if (!p)           //while 循环完也没有找到e,说明不存在e,返回0;
        return 0;
}


//插入操作
//在单链表中第i个位置插入一个结点，结点的元素值为e,插入成功返回1，失败返回0
int InsertList(LinkList head, int i, DataType e) 
{
    LinkNode *p, *pre;   //指针pre 是指向第i个元素的前驱结点，指针p指向新生成的结点
    int j;
    pre = head;
    j = 0;
    while (pre->next != NULL&&j < i - 1)     //为了找到第i-1个结点
    {
        pre = pre->next;
        j++;
    }
    if (j != i - 1)     //现在j应该等于 i-1,不等于说明没找到，插入位置错误
    {
        printf("插入位置错误");
        return 0;
    }
    if ((p = (LinkNode*)malloc(sizeof(LinkNode))) == NULL)    
        exit(-1);         //进程异常退出申请新结点失败
    p->data = e;
    //插入结点操作，顺序不能调换
    p->next = pre->next;
    pre->next = p;
    return 1;
}

//删除操作
//删除单链表中的第i个位置的结点。删除成功返回1，失败返回0
int DeleteList(LinkList head, int i, DataType *e) 
{
    LinkNode *p, *pre;
    int j;
    pre = head;
    j = 0;
    while (pre->next != NULL && pre->next->next != NULL && j < i - 1)
        /*判断是否找到前驱结点*/
    {
        pre = pre->next;
        j++;
    }
    if (j != i - 1)      //没有找到要删除的结点位置，说明删除位置错误
    {
        printf("删除位置错误");
        return 0;
    }
    //走到这里j=i-1
    //指针p指向单链表的第i个结点，并将该结点的数据域赋值给 e
    p = pre->next;
    *e = p->data;
    //将前驱结点的指针域指向要删除结点的下一个结点
    pre->next = p->next;
    //释放 p 指向的结点
    free(p);        
    return 1;
}

//求表长操作
//就是返回单链表元素个数
int ListLength(LinkList head) 
{
    LinkNode *p;
    int count = 0;
    p = head;
    while (p->next != NULL) 
    {
        p = p->next;
        count++;
    }
    return count;
}

//销毁链表操作  释放结点空间
void DestoryList(LinkList head) 
{
    LinkNode *p, *q;
    p = head;
    while (p != NULL)
    {
        q = p;
        p = p->next;
        free(q);
    }
}

这里写图片描述
这里写图片描述

例
存在两个单链表A和B，其中的元素都是非递减排列，编写算法归并单链表A和B，得到单链表C，C的元素值按照非递减排列。要求表C利用原来表A和B的结点空间，不申请额外空间

示例图

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

#define LISTSIZE 100
typedef int DataType;
#include "LinkList.h"

//将链表A和B的元素合并到C中的函数声明
void MergeList(LinkList A, LinkList B, LinkList *C);
void main()
{
    int i;
    DataType a[] = { 6,7,9,14,37,45,65,67 };
    DataType b[] = { 3,7,11,34,45,89 };
    LinkList A, B, C;
    LinkNode *p;
    InitList(&A);
    InitList(&B);
    InitList(&C);

    //将数组a中的元素插入到单链表A中
    for (i = 1; i <= (sizeof(a) / sizeof(a[0])); i++)
    {
        if (InsertList(A, i, a[i - 1]) == 0)
        {
            printf("位置不合法");
            return;
        }
    }
    //将数组b中的元素插入到单链表B中
    for (i = 1; i <= (sizeof(b) / sizeof(b[0])); i++)
    {
        if (InsertList(B, i, b[i - 1]) == 0)
        {
            printf("位置不合法");
            return;
        }
    }
    printf("单链表A中元素有%d个：\n", ListLength(A));
    for (i = 1; i <= ListLength(A); i++) 
    {
        p = Get(A, i);
        if (p)
            printf("%4d", p->data);
    }
    printf("\n");
    printf("单链表B中元素有%d个：\n", ListLength(B));
    for (i = 1; i <= ListLength(B); i++)
    {
        p = Get(B, i);
        if (p)
            printf("%4d", p->data);
    }
    printf("\n");
    MergeList(A, B, &C);
    printf("将单链表A和B合并到C后，C中的元素有%d个：", ListLength(C));
    for (i = 1; i <= ListLength(C); i++)
    {
        p = Get(C, i);
        if (p)
            printf("%4d", p->data);
    }
    printf("\n");
    system("pause");
}

/*单链表A和B中的元素非递减排列，将单链表A和B中的元素合并到C中，
  C中的元素仍然按照递减排列*/
void MergeList(LinkList A, LinkList B, LinkList *C) 
{
    LinkNode *pa, *pb, *pc;  //指向单链表A，B，C的指针
    pa = A->next;
    pb = B->next;
    *C = A;        //将单链表A的头结点作为C的头结点,此时不用释放A头结点
    (*C)->next = NULL;
    pc = *C;
    while (pa && pb)
    {
        if (pa->data <= pb->data)
        {
            //如果A中的元素小于或等于B中的元素，将A中的元素的结点作为C的结点
            pc->next = pa;
            //直接将指赋值给pc,包括了数据域和指针域
            pc = pa;
            pa = pa->next;
        }
        else
        {
            //如果A中的元素大于B中的元素，将B中的元素的结点作为C的结点
            pc->next = pb;
            pc = pb;
            pb = pb->next;
        }
    }
    pc->next = pa ? pa : pb;    //将剩余结点插入到C中
    free(B);                    //释放B的头结点
}

以上内容来自《跟我学数据结构》陈锐 葛丽萍编著，尊重作者，购买图书。

Spades_J
关注
  • 2
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构习题及详细答案
08-31
详细答案，经典题型，1. 1. LinkList mynote(LinkList L) {//L是不带头结点的单链表的头指针 if(L&&L->next){ q=L；L=L－>next；p=L； S1： while(p－>next) p=p－>next； S2： p－>next=q；q－>next=NULL； } return L； } 请回答下列问题： （1）说明语句S1的功能； （2）说明语句组S2的功能； （3）设链表表示的线性表为（a1,a2, …,an）,写出算法执行后的返回值所表示的线性表。 2. 2. void ABC(BTNode * BT) { if BT { ABC (BT->left); ABC (BT->right); cout<<BT->data<<' '; } } 该算法的功能是： 等等一些例题
单链表LinkList
12-31
使用数据结构中的方法，实现链式存储结构，达到节省空间的目的
数据结构试卷（一）
Alex
09-05 9856
一、单选题（每题 2 分，共20分） 栈和队列的共同特点是( A )。 A.只允许在端点处插入和删除元素 B.都是先进后出 C.都是先进先出 D.没有共同点 用链接方式存储的队列，在进行插入运算时( D ). A. 仅修改头指针 　 B. 头、尾指针都要修改 C. 仅修改尾指针 D.头、尾指针可能都要修改（尾插和头插） 以下数据结构中哪一个是非线性结构？( D ) A. 队列 　　 B. 栈 C. 线性表 　　 D. 二叉树（树结构） 设有一个二维数组A[m][n]，假设A[0][0]
线性表习题
Tang
01-19 1万+
<br />绪言和线性表习题<br />一、    选择题类型<br />1、.在一个单链表中，若p↑结点不是最后结点，在p↑之后插入s↑结点，则实行(      )。<br />  A. s->next=p；p->next=s;     <br />  B、 s->next=p->next; p->next=s；<br />  C. s->next=p->next;p=s;     <br />  D. p->next=s;s->next=p;<br />2.与单链表相比,双链表优点之一(   ).<br
链表中LinkList L与LinkList *L（ & * L.elem L-＞elem）
最新发布
2301_78066243的博客
04-17 482
LinkList L：L是结构体指针，使用“->“运算符来访问结构体成员；（*L）是结构体，使用"."运算符访问结构体成员函数是否有&看是否要返回该链表等，若返回加&，否则不加；与L->elem还是L.elem没有关系。
initlist函数c语言,线性表初始化int InitList(LinkList *L)和int InitList（LinkList L）问题...
weixin_39810901的博客
05-19 9029
在数据结构线性表一章，老师讲到，如果要改变变量的值就用指针，不改变就用变量本身，但是在代码中，定义线性表的数据结构如下def.htypedef struct Node{int data;struct Node * next;}Node;typedef struct Node* LinkList;初始化线性表的函数如下：int InitList(LinkList *L){*L = (LinkList...
单链表中 Linklist L 和 Linklist *L 的区别
qq_43278562的博客
06-20 3817
考研复习到单链表的时候，发现书中对于初始化单链表的代码些许不懂，查阅资料后想保存下来，因为写一篇以后不懂得时候可以看： 首先给出单链表存储结构的代码： typedef struct Node { ElemType data; struct Node * next; }Node,*Linklist; //Linklist为结构指针类型 在这里说明一下: Linklist 和Node * 同为结构指针类型，两者是等价的。习惯上Linklist强调是一个单链表，而Node * 强调这是一个节点。 继续说L
使用单链表实现多项式计算示例
12-31
代码如下:#include ...//错误返回之集合#define SUCCESS 0#define POINT_ARG_IS_NULL -1#define LINKLIST_IS_NULL -2#define NOT_FOUND -3 typedef struct{ int cst_term;//常数项 int idx_term;//指数}factor
单链表的实现
05-23
单链表实现：Status InitList(Linklist l);//初始化链表 Status CreateList(Linklist l,ElemType a[],int n);//创建链表 void InsertList(Linklist l,int i,ElemType e);//在第i个位置上插入e void DelList(Linklist...
Java单链表的实现代码
09-02
在Java编程中，单链表是一种基础的数据...总之，Java单链表的实现涉及创建`Node`类来表示链表节点，以及`LinkList`类来封装链表的操作。通过这些类和方法，我们可以有效地管理和操作单链表数据结构，满足各种编程需求。
c语言实现单链表算法示例分享
09-04
"c语言实现单链表算法示例分享" 单链表是一种基础的数据结构，在计算机科学中广泛应用。下面将详细介绍c语言实现单链表算法的示例。 1. 单链表的定义 单链表是一种链式数据结构，其中每个节点由数据域和指针域...
数据结构与算法-linklist逆转
09-16
#include <stdio.h> #include <stdlib.h> #define ERROR -1 #define OK 1 //定义单链表 typedef char ElemType; typedef struct LNode // 结点类型定义 { ElemType data; struct LNode * next; }LNode, *LinkList;//LinkList为结构指针类型 //定义关于单链表的若干操作 //初始化--建空表 void InitList(LinkList *L) { *L = (LinkList)malloc(sizeof(LNode)); (*L)->next=NULL; } //尾插法建表 void create_tail(LinkList *L, int n) { LNode *p, *last; int i; last=(*L); for(i=1; i<=n; i++) { p=(LNode *)malloc(sizeof(LNode)); //产生一个新结点 fflush(stdin); //清空内存 scanf("%c", &p->data); //往新结点的数据域中存入元素 last->next=p; //将新结点接在最后一个结点的后面 last=p; //新结点成为最后一个结点 } last->next=NULL; } //求单链表的长度 int ListLength(LinkList L) { LNode *p; int length; p=L->next; //p指针指向第一个元素所在的结点 length=0; //用来存放单链表的长度 while( p!=NULL ) //结点存在 { p=p->next; //p指针向后移 length++; //个数增加１个 } return length; } //求特定元素的个数 int Count(LinkList L, ElemType x) { LNode *p; int length; p=L->next; //p指针指向第一个元素所在的结点 length=0; //用来计算特定元素的个数 while( p ) //结点存在 { if( p->data ==x) //如果找到特定元素，则个数加１ length ++; p=p->next; //p指针向后移 } return length; } //在第i个元素前插入 int ListInsert_L(LinkList *L, int i, ElemType e) { LNode *p, *s; int j; p=(*L); j=0; while( p &&j<i-1) //如果当前结点存在，且移动次数未达到所需次数（找第i-1个结点） { p=p->next; j++; } if(!p || j>i-1) return ERROR; s=(LNode *)malloc(sizeof(LNode)); //产生一新结点 s->data=e; //往新结点中存入元素 s->next=p->next; p->next=s; //新结点接在p结点之后 return OK; } //删除第i个元素 int ListDelete_L(LinkList *L, int i, ElemType *e) { LNode *p,*q; int j; p=(*L); j=0; while(p->next && j<i-1)//（找第i-1个元素）如果当前结点的下一个结点存在，且移动次数未达到所需次数 { p=p->next; j++; } if(!p->next || j>i-1) return ERROR; q=p->next; p->next=q->next; *e=q->data; free(q); //释放要删除的结点 return OK; } void reverse(LinkList *L) { LNode *p,*q,*r; p=(*L)->next; q=p->next; r=q->next; p->next=NULL; while(q!=NULL) { q->next=p; (*L)->next=q; p=q; q=r; if(r!=NULL) r=q->next; else break; } } void main() { LinkList list1; InitList(&list1); create_tail(&list1, 5); LNode *p; for(p=list1->next; p; p=p->next ) printf("%c ",p->data ); printf("\n"); /* printf("\n========================================\n"); printf("\n单链表的长度：%d\n", ListLength(list1)); printf("\n========================================\n"); printf("单链表中元素c的个数：%d\n", Count(list1, 'c')); printf("\n========================================\n"); ListInsert_L(&list1, 3, 'g'); printf("在第3个元素前插入元素g后，单链表中的元素有：\n"); for(p=list1->next; p; p=p->next ) printf("%c ",p->data ); printf("\n"); printf("\n========================================\n"); ElemType e; ListDelete_L(&list1,4, &e); printf("删除第4个元素后，单链表中的元素有：\n"); for(p=list1->next; p; p=p->next ) printf("%c ",p->data ); printf("\n"); printf("删除掉的元素是：%c\n",e); */ reverse(&list1); for(p=list1->next; p; p=p->next ) printf("%c ",p->data ); }
c语言单链表的实现及测试
07-20
定义了单链表的基本操作，并在主函数中测试了所有定义的操作。
单链表实现图书管理系统.pdf
05-25
"单链表实现图书管理系统.pdf" 本文档介绍了使用单链表实现图书管理系统的设计和实现。该系统使用C++语言编写，主要功能包括图书信息的输入、输出、搜索、排序和逆序等。 单链表是一种常用的数据结构，它由多个...
Java单链表基本操作的实现
09-02
总之，Java中的单链表通过`Node`类和`LinkList`类实现了基本的数据操作，包括插入、删除等。理解这些概念对于深入学习数据结构和算法至关重要，也是成为一名优秀程序员的基础。希望这个简短的介绍能够帮助你更好地...
利用单链表实现有序表的合并.cpp .h
01-25
利用单链表实现有序表的合并的cpp文件和h文件，可以用来学习。 学习地址：https://blog.csdn.net/qq_39400324/article/details/122680864 template void LinkList<ElemType>::Merge(LinkList<ElemType>& L) { ...
LinkList L与LinkList *L Lnode与*LinkList的区别
m0_46314516的博客
10-13 7555
typedef struct node { int data; struct node* next; }Lnode,*LinkList; 对于结构体前面加typedef是给结构体起了个别名， struct node=Lnode struct node*=LinkList; Lnode L定义了一个结构体变量 LinkLnode L=Lnode *L=struct node *L定义的是一个指向node结构体的指针L，必须初始化，可以用->指向结构体成员变量 L->data;或者 (
【Dongle】【数据结构】Linklist L、Linklist *L、Node *p 和Node p
热门推荐
郑晓东 廊坊师范学院信息技术提高班 十二期
10-10 1万+
Linklist L、Linklist *L、Node *p 和Node p的区分
【数据结构】线性表（二）—— 单链表（C语言版）
haoweixl的博客
05-16 2530
// 链表：单向链表、 循环链表、 双向链表 // 头结点为 存取数据元素 的情况 #include <stdio.h> #include <stdlib.h> #include <time.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define......
单链表基本操作的实现
09-29
以下是单链表基本操作的实现代码： ```c /* 初始化链式线性表 */ Status IniList(LinkList *L) { *L = (LinkList)malloc(sizeof(Node)); /* 产生头结点，并使L指向此头结点 */ (*L)->next = NULL; /* 指针域为空 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值