复习链表

最新推荐文章于 2022-11-05 14:19:41 发布
最新推荐文章于 2022-11-05 14:19:41 发布
阅读量134 收藏
点赞数
分类专栏： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hujiaqi2018/article/details/81414425
版权

头文件：

#ifndef _LINKLIST_H
#define _LINKLIST_H

#define FAILURE    10000
#define SUCCESS    10001
#define TRUE       10002
#define FALSE      10003

typedef int ElemType; 

struct node
{
    ElemType data;   //数据域
    struct node *next;   //指针域//指向一个结构体数据的指针
};

typedef struct node Node;

int LinkInit(Node **l);//调用函数清单
int LinkInsert(Node *l, int n, ElemType e);
int LinkTraverse(Node *l, void (*p)(ElemType));
int LinkLength(Node *l);
int LinkEmpty(Node *l);
int GetElem(Node *l, int p, ElemType *e);
int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType));
int LinkDelete(Node *l, int p, ElemType *e);
int LinkClear(Node *l);
int LinkDestroy(Node **l);

#endif

链表的初始化

主函数：

int ret, i;
    Node *first = NULL;   //头指针

    srand(time(NULL));//取随机值

    ret = LinkInit(&first);//传地址，要修改指针里面的值
    if (ret == FAILURE)
    {
        printf("Init Failure!\n");
    }
    else
    {
        printf("Init Success!\n");
    }

调用函数：

int LinkInit(Node **l)
{
    *l = (Node *)malloc(sizeof(Node) * 1);   //分配头结点   l 就是头指针
    if (NULL == *l)
    {
        return FAILURE;
    }

    (*l)->next = NULL;    //头结点指针域为空

    return SUCCESS;

插入数据到链表：

第二轮：

 

 

主函数：

for (i = 0; i < 10; i++)
    {
        ret = LinkInsert(first, i + 1, rand() % 20);
        if (ret == FAILURE)
        {
            printf("Insert Failure!\n");
        }
        else
        {
            printf("Insert Success!\n");
        }
    }

调用函数：

int LinkInsert(Node *l, int n, ElemType e)  //n 插入的位置，这里头指针已经指向头结点所以送值没有问题
{
    Node *p = l;
    int k = 1;   //k 移动的次数

    if (NULL == l)
    {
        return FAILURE;
    }

    while (k < n && p != NULL)
    {
        p = p->next;
        k++;
    }

    if (k > n || p == NULL)
    {
        return FAILURE;
    }

    Node *q = (Node *)malloc(sizeof(Node) * 1);
    if (NULL == q)
    {
        return FAILURE;
    }

    q->data = e;   //数据域
    q->next = p->next;
    p->next = q;

    return SUCCESS;
}

浏览函数

主函数：


    ret = LinkTraverse(first, print);//调用函数
    if (ret == FAILURE)
    {
        printf("\nTraverse Falure!\n");
    }
    else
    {
        printf("\nTraverse Success!\n");
    }

调用函数：

void print(ElemType e)
{
    printf("%d ", e);
}

 

int LinkTraverse(Node *l, void (*p)(ElemType))定义函数指针指向print函数
{
    if (NULL == l)
    {
        return FAILURE;
    }
    Node *q = l;

    while (q->next)//当q的指针域不为空时循环
    {
        q = q->next;//q往后移动
        p(q->data);//将q的数据域引用输出到print函数
    }

链表的倒叙:

主函数：

ret = LinkReverse(first);
    if (ret == SUCCESS)
    {
        printf("Reverse Success!\n");
    }
    else
    {
        printf("Reverse Failure!\n");
    }

    调用函数：

int LinkReverse(Node *l)
{
    if (NULL == l)
    {
        return FAILURE;
    }

    Node *p = l->next;
    l->next = NULL;

    while (p != NULL)
    {
        Node *q = p;
        p = p->next;
        q->next = l->next;
        l->next = q; 
    }

    return SUCCESS;
}

 

 

测试长度

主函数：

    ret = LinkLength(first);
    if (ret == FAILURE)
    {
        printf("Get Length Failure!\n");
    }
    else
    {
        printf("length %d\n", ret);
    }

调用函数：

int LinkLength(Node *l)
{
    if (NULL == l)
    {
        return FAILURE;
    }

    int len = 0;
    Node *p = l->next;

    while (p)//当p指向不为空，一直到最后一个结点
    {
        len++;
        p = p->next;
    }

    return len;
}

判断是否为空？

主函数

    ret = LinkEmpty(first);
    if (ret == TRUE)
    {
        printf("List is empty!\n");
    }
    else if (ret == FALSE)
    {
        printf("List is not empty!\n");
    }
调用函数：

int LinkEmpty(Node *l)
{
    return (l->next == NULL) ? TRUE : FALSE;
}

 

获取元素函数：

主函数

int p = 10;//获取元素的位置
    ElemType e;//获取元素存储到e
    ret = GetElem(first, p, &e);
    if (ret == FAILURE)
    {
        printf("Get element failure!\n");
    }
    else
    {
        printf("The %dth element is %d\n", p, e);
    }

调用函数：

int GetElem(Node *l, int p, ElemType *e)    //p 位置
{
    if (NULL == l || p < 1)   //入参判断  p不能小于0
    {
        return FAILURE;
    }

    Node *q = l;
    int i;

    for (i = 0; i < p && q != NULL; i++)    //循环p次，同时满足q不为空
    {
        q = q->next;
    }

    if (!q)      //如果q为空，说明p（位置）大于长度
    {
        return FAILURE;
    }

    *e = q->data;     //q已经指向第p个结点

    return SUCCESS;
}

查询函数

主函数：

e = 10;

    ret = LocateElem(first, e, equal);//千千万万注意接收函数返回值用“=”不要用双 ==，否则函数会调用但没有接收到返回值。编译器不会报错
    if (FAILURE == ret)
    {
        printf("%d not exist!\n", e);
    }
    else
    {
        printf("%d is %dth element!\n", e, ret);
    }

调用函数：

int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType))
{
    if (NULL == l)
    {
        return FAILURE;
    }
    
    Node *q = l->next;
    int len = 1;

    while (q)
    {
        if (p(e, q->data) == TRUE)
        {
            return len;
        }
        q = q->next;
        len++;
    }

    return FAILURE;
}
 

int equal(ElemType e1, ElemType e2)
{
    return (e1 == e2) ? TRUE : FALSE;
}

删除函数

主函数：   

 p = 3;//删除的位置
    ret = LinkDelete(first, p, &e);
    if (ret == FAILURE)
    {
        printf("Delete Failure!\n");
    }
    else
    {
        printf("Delete %d Success!\n", e);
    }

调用函数：

int LinkDelete(Node *l, int p, ElemType *e)
{
    int k = 1;
    Node *q = l;//指向头结点

    if (l == NULL)
    {
        return FAILURE;
    }

    while (k < p && q != NULL)//循环次数小于删除位置，如果只有一个结点就不会进入循环
    {
        q = q->next;//使用q移动要删除数的前一个
        k++;
    }

    if (k > p || q == NULL)
    {
        return FAILURE;
    }

    Node *n = q->next;//指向第一个结点；或者q下面一个结点
    *e = n->data;//将要删除
    q->next = n->next;//将q指向后一个结点
    free(n);//释放删除结点

    return SUCCESS;
}
清空结点：

主函数：

ret = LinkClear(first);
    if (ret == SUCCESS)
    {
        printf("Clear Success!\n");
    }
    else
    {
        printf("Clear Failure!\n");
    }
调用函数

int LinkClear(Node *l)
{
    if (NULL == l)
    {
        return FAILURE;
    }

    Node *p = l->next;//将q指向第一个结点

    while (p)//当p不等于NULL时
    {
        l->next = p->next;//指向第二个结点
        free(p);删除第一个结点
        p = l->next;//防止为野指针
    }

    return SUCCESS;
}

销毁链表

主函数：

ret = LinkDestroy(&first);
    if (ret == SUCCESS)
    {
        printf("Destroy Success!\n");
    }
    else
    {
        printf("Destroy Failure!\n");
    }

    for (i = 0; i < 10; i++)
    {
        ret = LinkInsert(first, i + 1, rand() % 20);//在插入一边测试有没有毁掉
        if (ret == FAILURE)
        {
            printf("Insert Failure!\n");
        }
        else
        {
            printf("Insert Success!\n");
        }
    }

 

调用函数

int LinkDestroy(Node **l)//如果Node *l传值是定义一个指针指向同一块内存
{
    if (l == NULL)
    {
        return FAILURE;
    }
    free(*l);//
    (*l) = NULL;//但如果只用一级指针虽然会释放malloc分配的内存，但是会让头指针first变成野指针会出错；而二级指针*l可以直接对指针操作

    return SUCCESS;
}

hujiaqi2018
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表复习
weixin_51781028的博客
04-29 104
链表的基本操作: 创建头，头插，尾插，增，删，改，查； 基本结构 结构体+主函数+子函数。 结构体： 链表的结构体分为数据域和指针域两部分，单链表的指针域只有一个指针，指向的是下一个节点，而双链表的指针域中存在两个指针，这两个指针域分别指向下一个节点和上一个结点。 typedef struct node { int data; node *next; }Node, *pNode; 这里的node 和 Node地区别： node：只是一个名字，跟学生管理系统中的student相同，用node是因为no
链表复习！
qq_48094059的博客
07-22 341
链表
（一）链表复习
m0_62720905的博客
01-20 315
node *p; p = new node; p = (node*) malloc (size(node)); 动态分配函数，C语言里是malloc，C++里是new； 单链表--顺序建表 #include<bits/stdc++.h> using namespace std; struct node{ int data; node *next; }; node* creat(int n) //顺序建表 { node *head, *tail, *p; .
数据结构复习之链表
01-17
在本复习中，我们将深入探讨链表的概念、类型以及常见操作。 链表的基本构成单元是节点，每个节点包含两部分：数据域和指针域。数据域用于存储实际的元素值，而指针域则保存指向下一个节点的引用。链表的最后一个...
链表（复习）资料
10-28
一、复习要点 本章复习的要点： 1、基本知识点 单链表是一种线性结构，链表各结点的物理存储可以是不连续的，因此各结点的逻辑次序与物理存放次序可以不一致。必须理解单链表的定义和特点，单链表的抽象数据类型和类...
数据分析，链表相关复习
最新发布
03-02
数据结构。
C++指针和链表复习题
04-07
C++ 针对C++大学教程中指针和链表两章的复习题，附有答案在最后，大家做完可以自己对答案核查！
数据结构复习笔记-静态链表
10-29
图和代码相结合，详细讲解静态链表。通过生动活泼的对话让读者理解内村动态申请。
链表复习（一）
prince~home
10-24 9016
链表的经典应用场景：LRU缓存淘汰算法 决定缓存淘汰的三种策略：先进先出FIFO、最少使用策略LFU、最近最少使用策略LRU 书房清理书籍与缓存淘汰策略相同 链表和数组的区别 数组需要一块连续的内存空间存值，对内存的要求高。如果申请100MB，可是内存中没有连续的足够的存储空间，即便剩余内存大于100MB还是会申请失败 链表并不需要一块连续的内存空间，他通过“指针”将一组零散的内存块串联...
简单的链表复习
weixin_44234294的博客
07-17 123
今天复习链表 先写了一个很low的数字链表，实现想在那个数字前后插入新的节点（静态创建的） #include <stdio.h> #include <stdlib.h> #include <string.h> struct Test { int data; struct Test *next; }; void printLink(struct Test *t1) { struct Test *p=t1; while(1){ if(p != NULL){
链表复习（单链表）
weixin_53310322的博客
12-19 622
链表复习（主要是单链表）1.链表的概念2.链表的实现2.1 节点封装类2.2 Link类3.实例3.1 LeetCode 2 ：两数相加3.2 LeetCode 19 ：删除链表的倒数第n个节点 1.链表的概念 数据域：存储元素信息的空间（可以是数组）。 指针域：数据域的后继位置为指针域。用于存放指针。 指针/链：指针用于节点之间的联系。 节点：数据域和指针域共同组成节点。 头节点：头结点是为了操作的统一与方便而设立的，放在第一个元素结点之前，其数据域一般无意义。 2.链表的实现 2.1 节点封装
数据结构复习——链表（一）
kk_lmy的博客
11-05 113
数据结构第一章链表复习（一）
数据结构复习（二）----链表
m0_51530227的博客
09-03 141
数据结构复习（二）—链表 链表基本分类 1.单链表 2.双链表 3.循环链表 链表定义和图示化表达 简言之，就是data加next指针打包在一起； 链表的基本操作： 1.链表的定义 #define Elemtype int typedef struct LNode { Elemtype data; LNode* next; }LinkList; 2.链表的基本操作 1.头插法建表 void CreateListHead(LinkList*&L, int a[],int n) { L=(Lin
03-15复习链表知识
tjh1998的博客
03-15 386
链表的总结
链表的各种题目整理(C语言实现)
yinshiwei2000lh的专栏
11-07 1500
链表的各种题目整理(C语言实现)   这里处理的全部是单链表: typedef struct node { char *data; struct node *next; } node_t; 我们约定一个打印链表的函数: void list_display(node_t *head) { for (; head; head = he
双链表和循环双链表复习
hujiaqi2018的博客
08-10 4123
首先不管是单链表还是双链表或者循环双链表，都是为了提高访问效率，比如同样的插入操作，顺序表需要用数组移动元素，访问效率比较差，相反链表只需要移动指针，而且顺序表是有最大空间的，而链表没有。 双链表格式： struct node     //双向链表 {     ElemType data;   //数据域     struct node *next;   //指针域   指向下一个后继方向 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值