简单单向链表的学习和使用//2018.07.24

最新推荐文章于 2022-07-21 22:31:01 发布
最新推荐文章于 2022-07-21 22:31:01 发布
阅读量172 收藏
点赞数
分类专栏： C语言 Linux 文章标签： C语言单向链表的学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31421117/article/details/81191941
版权

  学习日志        姓名：叶圣民   日期：2018.07.24.

 

 

 

 

今日学习任务

 

 

 

掌握单项链表的使用

今日任务完成情况

 

（详细说明本日任务是否按计划完成，开发的代码量）

链表的分类：单链表、单向循环链表、双链表、双向循环链表

 

链表是数据结构：管理数据（存、取、遍历、查找）

 

链表的作用：解决数组带来的空间利用问题

            数组静态分配空间；容易造成浪费；链表动态分配空间

结点：数据域 和 链接域

 

链接表：①定义结点类型    typedef 重命名

        ②定义头指针

        ③初始化链表

        ④定义添加结点函数

 

 

 今日开发中出现的问题汇总

 

链表的逆序

有表头链表的逆序

 

今日未解决问题

 

无

 

 

①简单结构体

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

struct node
{
    int num;
    struct node *next;
};

int main()
{
    struct node *head = (struct node *)malloc(sizeof(struct node));
    struct node *p1 = (struct node *)malloc(sizeof(struct node));
    struct node *p2 = (struct node *)malloc(sizeof(struct node));
    struct node *p3 = (struct node *)malloc(sizeof(struct node));

    p1->num = 1;
    p1->next = p2;

    p2->num = 2;
    p2->next = p3;

    p3->num = 3;
    p3->next = NULL;

    head = p1;

    while(head != NULL)
    {
        printf("%d\n",head->num);
	head = head->next;
    }
    
    
    return 0;
}

 

②头插入结点

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


struct node
{
    int num;

    struct node *next;
};

typedef struct node Node;
typedef Node * Link;

void init(Link *head)
{
    *head = NULL;
}

void insert_head(Link newnode,Link *head)
{
    if(*head == NULL)
    {
        newnode->next = NULL;
	*head = newnode;
    }
    else
    {
        newnode->next = *head;
        *head = newnode;
    }
}

#if 0
void insert_tail(Link newnode,Link *head)
{
    if(*head == NULL)
    {
        newnode->next = NULL;
        *head = newnode;
    }
    else
    {
        Link tmp = *head;
	while(tmp->next != NULL)
	{
	    tmp = tmp->next;
	}
	newnode->next = NULL;
	tmp->next = newnode;
    }
}
#endif


void display(Link head)
{
    Link temp = head;
    while(temp != NULL)
    {
        printf("%d\n",temp->num);
	temp = temp->next;
    }
}


int main()
{
    int i;

    Link head;
    Link newnode;

    init(&head);

    for(i = 0;i < 10; i++)
    {
        Link newnode = (Link)malloc(sizeof(Node));
        newnode->num = i + 1;
	insert_head(newnode,&head);
    }
    
    display(head);

    return 0;
}

 

③尾插入结点

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


struct node
{
    int num;

    struct node *next;
};

typedef struct node Node;
typedef Node * Link;

void init(Link *head)
{
    *head = NULL;
}

#if 0
void insert_head(Link newnode,Link *head)
{
    if(*head == NULL)
    {
        newnode->next = NULL;
	*head = newnode;
    }
    else
    {
        newnode->next = *head;
        *head = newnode;
    }
}
#endif

void insert_tail(Link newnode,Link *head)
{
    if(*head == NULL)
    {
        newnode->next = NULL;
        *head = newnode;
    }
    else
    {
        Link tmp = *head;
	while(tmp->next != NULL)
	{
	    tmp = tmp->next;
	}
	newnode->next = NULL;
	tmp->next = newnode;
    }
}



void display(Link head)
{
    Link temp = head;
    while(temp != NULL)
    {
        printf("%d\n",temp->num);
	temp = temp->next;
    }
}


int main()
{
    int i;

    Link head;
    Link newnode;

    init(&head);

    for(i = 0;i < 10; i++)
    {
        Link newnode = (Link)malloc(sizeof(Node));
        newnode->num = i + 1;
	insert_tail(newnode,&head);
    }
    
    display(head);

    return 0;
}

 

 

④任意位置插入单个结点

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

/***枚举***/
enum Judge
{
    Link_empty,
    Link_insert_fail,
    Link_insert_success,
    Delete_empty,
    Delete_success,
    Delete_fail,
    Reverse_success,
    Reverse_fail
};

/***定义结构体***/
struct node
{
    int num;

    struct node *next;
};

/***重命名***/
typedef struct node Node;
typedef Node * Link;

/***初始化 head***/
void init(Link *head)
{
    *head = NULL;
}

/***头插***/
#if 0
void insert_head(Link newnode,Link *head)
{
    if(*head == NULL)
    {
        newnode->next = NULL;
	*head = newnode;
    }
    else
    {
        newnode->next = *head;
        *head = newnode;
    }
}
#endif

/***尾插***/
void insert_tail(Link newnode,Link *head)
{
    if(*head == NULL)
    {
        newnode->next = NULL;
        *head = newnode;
    }
    else
    {
        Link tmp = *head;
	while(tmp->next != NULL)
	{
	    tmp = tmp->next;
	}
	newnode->next = NULL;
	tmp->next = newnode;
    }
}


/***中间插入***/
#if 0
int insert_mid(Link newnode,Link *head,int n)
{
    if(*head == NULL)
    {
        return Link_empty;
    }
    
    Link temp = *head;
    
    while(temp != NULL)
    {
	if(temp->num == n)
	{
	    newnode->next = temp->next;
	    temp->next = newnode;
	    return Link_insert_success;
	}
	
	temp = temp->next;
    }
    
    return Link_insert_fail;
}
#endif


/***删除节点***/
#if 0
int delete_node(Link *head, int n)
{
    if(*head == NULL)
    {
        return Delete_empty;
    }
    
    Link tmp = *head;
    
    if((*head)->num == n)
    {
        *head = (*head)->next;
	free(tmp);
	tmp = NULL;
	return Delete_success;
    }
    else
    {
        Link p = tmp;
	tmp = tmp->next;
	while(tmp != NULL)
	{
	    if(tmp->num == n)
	    {
	        p->next = tmp->next;
		free(tmp);
		tmp = NULL;
		return Delete_success;
	    }
	    p = tmp;
	    tmp = tmp->next;
	}
        return Delete_fail;
    }
}
#endif


/***逆序链表***/
#if 1
int reverse_node(Link *head)
{
    if((*head == NULL) || ((*head)->next == NULL))
    {
        return Reverse_fail;
    }
    else
    {
        Link temp = *head;
        Link p = temp->next;
        Link s = p->next;
	while(temp != NULL)
	{
	    p->next = s;
	    s = p;
	    p = temp;
	    temp = temp->next;
	}
	p->next = s;
	(*head)->next = NULL;
	*head = p;
	return Reverse_success;
    }
}
#endif


/***显示链表***/
void display(Link head)
{
    Link temp = head;
    while(temp != NULL)
    {
        printf("%d\n",temp->num);
	temp = temp->next;
    }
}


int main()
{
    int i;

    Link head;
    Link newnode;

    init(&head);

#if 1
    for(i = 0;i < 10; i++)
    {
        Link newnode = (Link)malloc(sizeof(Node));
        newnode->num = i + 1;
	insert_tail(newnode,&head);
    }
#endif

    display(head);

#if 0
    int result2 = delete_node(&head,6);
    if(result2 == Delete_empty)
    {
        printf("The link is empty.\n");
    }
    if(result2 == Delete_success)
    {
        display(head);
    }
    if(result2 == Delete_fail)
    {
        printf("Delete fail!\n");
    }
#endif

#if 0
    newnode = (Link)malloc(sizeof(Node));
    newnode->num = 11;
    int result1 = insert_mid(newnode,&head,5);
    {
        if(result1 == Link_empty)
	{
	    printf("链表为空\n");
	}
	if(result1 == Link_insert_success)
	{
            display(head);
	}
	else
	{
	    printf("链表插入失败\n");
	}
    }
#endif
    
    int result3 = reverse_node(&head);
    if(result3 == Reverse_fail)
    {
        printf("\n");
    }
    if(result3 == Reverse_success)
    {
        display(head);
    }
    
    return 0;
}

 

⑤有表头的单向链表

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

/***枚举***/
enum Judge
{
    Link_empty,
    Link_insert_fail,
    Link_insert_success,
    Delete_empty,
    Delete_success,
    Delete_fail,
    Reverse_success,
    Reverse_fail
};

/***定义结构体***/
struct node
{
    int num;

    struct node *next;
};

/***重命名***/
typedef struct node Node;
typedef Node * Link;

/***初始化 head***/
void init(Link *head)
{
    *head = (Link)malloc(sizeof(Node));
    (*head)->next = NULL;
}

/***头插***/
#if 0
void insert_head(Link newnode,Link *head)
{
    newnode->next = (*head)->next;
    (*head)->next = newnode;
}
#endif

/***尾插***/
#if 0
void insert_tail(Link newnode,Link *head)
{
    Link tmp = *head;
    while(tmp->next != NULL)
    {
	tmp = tmp->next;
    }
    newnode->next = tmp->next;
    tmp->next = newnode;
}
#endif

/***中间插入***/
#if 1
int insert_mid(Link newnode,Link *head,int n)
{
    Link temp = *head;
    
    while(temp != NULL)
    {
	if(temp->num == n)
	{
	    newnode->next = temp->next;
	    temp->next = newnode;
	    return Link_insert_success;
	}
	
	temp = temp->next;
    }
    
    return Link_insert_fail;
}
#endif


/***删除节点***/
#if 0
int delete_node(Link *head, int n)
{
    if(*head == NULL)
    {
        return Delete_empty;
    }
    
    Link tmp = *head;
    
    if((*head)->num == n)
    {
        *head = (*head)->next;
	free(tmp);
	tmp = NULL;
	return Delete_success;
    }
    else
    {
        Link p = tmp;
	tmp = tmp->next;
	while(tmp != NULL)
	{
	    if(tmp->num == n)
	    {
	        p->next = tmp->next;
		free(tmp);
		tmp = NULL;
		return Delete_success;
	    }
	    p = tmp;
	    tmp = tmp->next;
	}
        return Delete_fail;
    }
}
#endif


/***逆序链表***/
#if 0
int reverse_node(Link *head)
{
    if((*head == NULL) || ((*head)->next == NULL))
    {
        return Reverse_fail;
    }
    else
    {
        Link temp = *head;
        Link p = temp->next;
        Link s = p->next;
	while(temp != NULL)
	{
	    p->next = s;
	    s = p;
	    p = temp;
	    temp = temp->next;
	}
	p->next = s;
	(*head)->next = NULL;
	*head = p;
	return Reverse_success;
    }
}
#endif


/***显示链表***/
void display(Link head)
{
    Link temp = head->next;
    while(temp != NULL)
    {
        printf("%d\n",temp->num);
	temp = temp->next;
    }
}


int main()
{
    int i;

    Link head;
    Link newnode;

    init(&head);

#if 1
    for(i = 0;i < 10; i++)
    {
        Link newnode = (Link)malloc(sizeof(Node));
        newnode->num = i + 1;
	insert_tail(newnode,&head);
    }
#endif

    display(head);

#if 0
    int result2 = delete_node(&head,6);
    if(result2 == Delete_empty)
    {
        printf("The link is empty.\n");
    }
    if(result2 == Delete_success)
    {
        display(head);
    }
    if(result2 == Delete_fail)
    {
        printf("Delete fail!\n");
    }
#endif

#if 0
    newnode = (Link)malloc(sizeof(Node));
    newnode->num = 11;
    int result1 = insert_mid(newnode,&head,5);
    {
        if(result1 == Link_empty)
	{
	    printf("链表为空\n");
	}
	if(result1 == Link_insert_success)
	{
            display(head);
	}
	else
	{
	    printf("链表插入失败\n");
	}
    }
#endif
    
#if 0
    int result3 = reverse_node(&head);
    if(result3 == Reverse_fail)
    {
        printf("\n");
    }
    if(result3 == Reverse_success)
    {
        display(head);
    }
#endif


    return 0;
}


 

 

 

 

 

 

 

 

 

 

1024

Ultraman0803
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表的使用（创建学生链表：实现增加学生，对年龄排序，逆序，查找与需要年龄最近的学生）//2018.07.25.
qq_31421117的博客
07-25 1360
.1.题目:创建两个学生链表,含有姓名、年龄的信息，一个链 表存放男生，一个链表存放女生。 .2.题目:将上面两个链表合并，按学生的年龄进行排序，合 成新的链表. .3.题目:将上题中建立的链表进行反转，实现按年龄的逆序 排列 .4.题目:在上面的实现的新链表中，给定一个年龄，迅速查 找和该学生年龄最接近的学生姓名。 综合后的代码：链表实现增加学生信息；按...
VC 单向/双向链表模板类实例二则.rar
07-09
这对于初学者来说是很好的实践和学习资源，可以通过阅读和运行代码来理解链表的工作原理。 总的来说，通过理解和实践这些链表模板类，你可以深入理解链表数据结构，掌握其在C++中的实现方式，这在解决许多算法问题...
苏嵌//张朋//2018.07.24
CSDN_Imagine的博客
07-24 151
苏嵌                                                                                                                                   项目实战 学习日志                                       姓名：张朋           ...
苏嵌//孙勇//2018.07.24
ygbrother的博客
07-24 112
苏嵌                                                                                                                                   项目实战 学习日志                                       姓名：孙勇           ...
苏嵌 学习日志 吴浩南 2018.07.24
qq_42657769的博客
07-24 96
      今日学习任务   掌握单项链表的使用   今日任务完成情况   （详细说明本日任务是否按计划完成，开发的代码量） 链表的分类：单链表、单向循环链表、双链表、双向循环链表 链表是数据结构：管理数据（存、取、遍历、查找） 链表的作用：解...
JAVA面试题（转自https://blog.csdn.net/weixin_38399962/article/details/80358168）
sinat_33462561的博客
04-11 1124
2019JAVA面试题附答案(长期更新) 2018年05月17日 22:53:57 晴天小哥哥 阅读数：39309 ...
python单向链表逆序_Python实现链表倒序（带头指针）
weixin_39984442的博客
11-20 86
原博文2018-12-07 17:43 −class ListNode(object): def __init__(self, x): self.val = x self.next = None def reverseList(self, head): if head == None or head.next =...相关推荐2019-09-28 21:13 −Pytho...
前端学习日记 --七月
Nana_9457的博客
08-01 1305
20190703 1、react300问： react的合成事件：初步了解e.nativeEvent https://segmentfault.com/a/1190000015725214 2、Visual DOM工作原理： 3、高阶组件 举例：增加props function HOC(WrappedComponent){ return class Text extends Component...
RTT里的单向链表
u011099585的专栏
07-21 699
RTT
05链表(上)
desmond的专栏
12-22 191
文章目录1.底层存储结构2.分类2.1 单链表2.1.1 概念2.1.1 时间复杂度2.2 双向链表2.2.1概念2.2.2 复杂度2.2.3 单链表、双向链表优劣2.3 循环链表3.性能:链表 V.S. 数组4.基于链表的LRU缓存淘汰算法4.1 思路4.2 实现4.3 复杂度分析4.4 引入hash结构降低复杂度5.基于数组的LRU缓存淘汰算法5.1 思路5.2 实现5.3 复杂度分析 1.底...
04.单向链表以及单向链表的应用.ppt
03-02
04.单向链表以及单向链表的应用.ppt
9-2 Abstract List Lib.zip_lib/list_debug._list_nodded68x
09-25
在本项目中，我们关注的是一个名为"9-2 Abstract List Lib.zip_lib/list_debug._list_nodded...通过分析和使用这个自定义抽象链表类，我们可以更好地掌握链表在实际项目中的应用，并从中学习到如何设计高效的数据结构。
lianbiao.rar_单向链表
09-24
单向链表是一种基本的数据结构，它在计算机科学和编程中有着广泛的应用。与数组不同，链表中的元素不是在内存中连续...学习这些内容可以帮助我们深入理解和掌握单向链表的原理和实践，提升编程技能和解决问题的能力。
TongXunLu.rar_单向链表
09-21
单向链表是一种常见的数据结构，它在计算机科学中被广泛应用，特别是在实现各种算法和数据管理中。在“TongXunLu.rar_单向链表”这个项目中，我们看到的是利用单向链表来构建一个同学录系统，该系统能够进行信息的增...
（Linux）简单电子通讯录
qq_31421117的博客
08-10 1378
设备：VMware虚拟机（Redhat镜像） 电子通讯录 功能：1.用户的注册 2.用户登录 3.用户修改密码 4.忘记密码，找回 5.退出程序 6.用户是否存在检查 7.密码是否正确检查 8.用户个人通讯录的信息管理 ① 添加成员信息 ② 查看成员信息 ③ 查找成员信息 ...
嵌入式 Linux 开发工具篇问题整理//C语言测试（杨辉三角、递归调用实现阶乘、计算器、统计字符串出现次数）//2018.07.12.//
qq_31421117的博客
07-12 712
嵌入式Linux开发工具篇问题整理 1、嵌入式开发与传统开发的区别？（同类问题：单片机开发与嵌入式开发的区别） 是否有无操作系统； 2、移植操作系统的好处有哪些？ 1.降低了 软件 和 硬件 的 耦合度；可移植性 适应各种硬件平台； 2.降低了对软件开发人员的要求（只需懂软件编写）； 3.提供了多任务机制； 4.提供网络协议栈...
C语言数据类型练习（素数、完输、报数游戏、数字排序）//学习日志//2018.07.14.//
qq_31421117的博客
07-14 315
Training 1:整数算法训练 1.题目:通过编程实现,统计1~n有多少个9 提示:n通过参数传入 2.题目:有n个人围成一圈,顺序排号,从第一个开始报数(从1到3报数),凡报到3的人退出圈子,问最后最后留下的是原来第几号的那位. 提示:用数组完成 3.题目:输入5个数(含负数、小数)将它们按由小到大的顺序排列起来 提示：需要排数的数字通过参数传递进来， 例如：输入:./...
格式化输入输出、数据类型//日期：2018.07.13.
qq_31421117的博客
07-13 297
今日学习任务 1、了解C 语言特点（优缺点、嵌入式开发中的地位，如何学习语言编程） 2、了解基本数据类型的定义及输入输出；（内置类型） 3、掌握字节长度与取值范围；（计算机存储数据的方式、sizeof的使用） 4、熟练掌握指针的定义与使用；（对应内存空...
:https://www.cnblogs.com/yosha/p/5528312.html
最新发布
04-10
作者介绍了一些基本的数据结构，如数组、链表、树等，并对它们的特点和使用进行了详细的讲解。此外，作者还介绍了一种基于链表实现的LRU缓存淘汰算法，并通过代码的形式展示了其实现方式。总之，这篇文章介绍了许多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值