链表例子程序

最新推荐文章于 2022-08-08 18:42:30 发布
最新推荐文章于 2022-08-08 18:42:30 发布
阅读量410 收藏 1
点赞数
分类专栏： Linux C 数据结构 文章标签： 链表 typedef 应用 linux-c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/viewsky11/article/details/53157156
版权

链表应用1：

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdint.h>

#include <signal.h>

#include <pthread.h>

#include <semaphore.h>

#include <unistd.h>


typedef int pri_spin_t;
pri_spin_t spin_flag = 1;
#define MAX_READ_ENTY 10

typedef struct _listp
{
  struct _listp *next;
    struct _listp *prev;
    int data;
}LISTP;

void pri_spin_lock(pri_spin_t *flag)
{
    while(1){
        if(*flag){
            *flag = 0;
            return;
        }
    }
}

void pri_spin_unlock(pri_spin_t *flag)
{
    *flag = 1;
}

void init_list_head(LISTP *listp)
{
    listp->next = listp;
    listp->prev = listp;
}

void list_add(LISTP *list_head, LISTP *listp)
{
    list_head->next->prev = listp;
    listp->next = list_head->next;
    listp->prev = list_head;
    list_head->next = listp;
}

void list_add_tail(LISTP *list_head, LISTP *listp)
{
    list_head->prev->next = listp;
    listp->prev = list_head->prev;
    listp->next = list_head;
    list_head->prev = listp;
}

int list_is_empty(LISTP *list_head)
{
    return (list_head->next == list_head);
}

void list_del(LISTP *listp)
{
    LISTP *prev;
    LISTP *next;
    prev = listp->prev;
    next = listp->next;
    prev->next = next;
    next->prev = prev;

    listp->next = listp;
    listp->prev = listp;
}

void free_list(LISTP *list_head)
{
    LISTP *pos = NULL;
    pos = list_head->next;
    while(pos != list_head){
        list_del(pos);
        free(pos);
        pos = list_head->next;
        printf("free\n");
    }
    if((list_head->next == list_head->prev) && (list_head->next == list_head)){
        printf("list empty\n");
    }
    list_head->next = NULL;
    list_head->prev = NULL;
    free(list_head);
}

int add_data(int data, LISTP *list_head)
{
    LISTP *listp = NULL;

    listp = (LISTP *)malloc(sizeof(LISTP));
    if(listp == NULL){
        printf("%s : can not get memory\n", __FUNCTION__);
        return -1;
    }
    listp->data = data;
    list_add(list_head, listp);
}

int add_data_tail(int data, LISTP *list_head)
{
    LISTP *listp = NULL;
    listp = (LISTP *)malloc(sizeof(LISTP));
    if(listp == NULL){
        printf("%s: can not get memory\n", __FUNCTION__);
        return -1;
    }
    listp->data = data;
    list_add_tail(list_head, listp);
}

void print_data(LISTP *list_head)
{
    int data;
    LISTP *pos;
    if(list_is_empty(list_head)){
        printf("list head is empty\n");
        return;
    }
    for(pos = list_head->next; pos != list_head; pos = pos->next){
        if(pos){
            if(pos->next == list_head)
                printf("%d\n", pos->data);
            else
                printf("%d\t", pos->data);
        }
    }
}

void read_data(LISTP *list_head, int num)
{
    int data;
    LISTP *entry;

    if(list_is_empty(list_head)){
        printf("list head is empty\n");
        return;
    }
    if(num > MAX_READ_ENTY){
        num = MAX_READ_ENTY;
    }
    printf("read message is :\n");
    for(entry = list_head->next; (entry != list_head) && (num > 0); entry = list_head->next){
        printf("%d\t", entry->data);
        list_del(entry);
        entry->next = NULL;
        entry->prev = NULL;
        free(entry);
        num--;
    }
    printf("\n");   
}

void *send_message_pth1(void *arg)
{
    int i = 0;
    while(1){
        pri_spin_lock(&spin_flag);
        add_data_tail(i, (LISTP *)arg);
        printf("------IN SEDND MESSAGE PTHREAD 1-------\n");
        pri_spin_unlock(&spin_flag);
        i++;
        sleep(2);
    }
}

void *send_message_pth2(void *arg)
{
    int i = 0;
    while(1){
        pri_spin_lock(&spin_flag);
        add_data_tail(i, (LISTP *)arg);
        printf("------IN SEDND MESSAGE PTHREAD 2---------\n");
        pri_spin_unlock(&spin_flag);
        i++;
        sleep(2);
    }
}

void *print_message_pth(void *arg)
{
    while(1){
        pri_spin_lock(&spin_flag);
        printf("--------IN PRINT MESSAGE PTHREAD----------\n");
        print_data((LISTP *)arg);
        pri_spin_unlock(&spin_flag);
        sleep(2);
    }
}

void *read_message_pth(void *arg)
{
    int num = 5;
    while(1){
        pri_spin_lock(&spin_flag);
        printf("-------IN READ MESSAGE PTHREAD---------\n");
        read_data((LISTP *)arg, num);
        pri_spin_unlock(&spin_flag);
        sleep(6);
    }
}

int main(int argc, char *argv[])
{
    /* code */
    int i = 0;
    LISTP *list_head = NULL;
    pthread_t pth1;
    pthread_t pth2;
    pthread_t pth3;
    pthread_t pth4;
    list_head = (LISTP *)malloc(sizeof(LISTP));
    if(list_head == NULL){
        printf("can not get memory\n");
        return -1;
    }
    init_list_head(list_head);

    for(i = 0; i < 10; i++){
        pri_spin_lock(&spin_flag);
        add_data_tail(i, list_head);
        pri_spin_unlock(&spin_flag);
    }

    if(pthread_create(&pth1, NULL, (void *)send_message_pth1, list_head)){
        printf("create pthread failed\n");
        return -1;
    }
    if(pthread_create(&pth1, NULL, (void *)send_message_pth2, list_head)){
        printf("create pthread failed\n");
        return -1;
    }
    if(pthread_create(&pth3, NULL, (void *)print_message_pth, list_head)){
        printf("create pthread failed\n");
        return -1;
    }
    if(pthread_create(&pth4, NULL, (void *)read_message_pth, list_head)){
        printf("create pthread failed\n");
        return -1;
    }
    while(1);
    return 0;
}

链表应用2： 

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdint.h>

#include <signal.h>

#include <pthread.h>

#include <semaphore.h>

#include <unistd.h>


typedef int pri_spin_t;

#define MAX_READ_ENTRY 10

#define GET_ADDR_BY_OFFSET(ptr, type, member) ((type *)((char *)ptr - (uint32_t)(&(((type *)0)->member))))


typedef struct _listp
{
  struct _listp *next;
    struct _listp *prev;
}LISTP;

typedef struct _list_msg
{
    int data;
    LISTP list;
}LIST_MSG;

typedef struct _module_struct 
{
    LISTP list_head;
    pri_spin_t spin_flag;
}MODULE_STRUCT;

void pri_spin_lock(pri_spin_t *flag)
{
    while(1){
        if(*flag){
            *flag = 0;
            return;
        }
    }
}

void pri_spin_unlock(pri_spin_t *flag)
{
    *flag = 1;
}

void init_list_head(LISTP *listp)
{
    listp->next = listp;
    listp->prev = listp;
}

void list_add(LISTP *list_head, LISTP *listp)
{
    list_head->next->prev = listp;
    listp->next = list_head->next;
    listp->prev = list_head;
    list_head->next = listp;
}

void list_add_tail(LISTP *list_head, LISTP *listp)
{
    list_head->prev->next = listp;
    listp->prev = list_head->prev;
    listp->next = list_head;
    list_head->prev = listp;
}

int list_is_empty(LISTP *list_head)
{
    return (list_head->next == list_head);
}

void list_del(LISTP *listp)
{
    LISTP *prev;
    LISTP *next;
    prev = listp->prev;
    next = listp->next;
    prev->next = next;
    next->prev = prev;

    listp->next = listp;
    listp->prev = listp;
}

void free_list(LISTP *list_head)
{
    LISTP *pos = NULL;
    pos = list_head->next;
    while(pos != list_head){
        list_del(pos);
        free(pos);
        pos = list_head->next;
        printf("free\n");
    }
    if((list_head->next == list_head->prev) && (list_head->next == list_head)){
        printf("list empty\n");
    }
    list_head->next = NULL;
    list_head->prev = NULL;
    free(list_head);
}

int add_data(int data, LISTP *list_head)
{
    LIST_MSG *list_message = NULL;

    list_message = (LIST_MSG *)malloc(sizeof(LIST_MSG));
    if(list_message == NULL){
        printf("%s : can not get memory\n", __FUNCTION__);
        return -1;
    }
    init_list_head(&(list_message->list));
    list_message->data = data;
    list_add(list_head, &(list_message->list));
    return 0;
}

int add_data_tail(int data, LISTP *list_head)
{
    LIST_MSG *list_message = NULL;

    list_message = (LIST_MSG *)malloc(sizeof(LIST_MSG));
    if(list_message == NULL){
        printf("%s: can not get memory\n", __FUNCTION__);
        return -1;
    }
    init_list_head(&(list_message->list));

    list_message->data = data;
    list_add_tail(list_head, &(list_message->list));
    return 0;
}

void print_data(LISTP *list_head)
{
    int data;
    LISTP *pos;
    LIST_MSG *message;

    if(list_is_empty(list_head)){
        printf("list head is empty\n");
        return;
    }

    for(pos = list_head->next; pos != list_head; pos = pos->next){
        if(pos){
            message = GET_ADDR_BY_OFFSET(pos, LIST_MSG, list);
            if(message){
                printf("%d\t", message->data);
            }
        }
    }
    printf("\n");
}

void read_data(LISTP *list_head, int num)
{
    int data;
    LISTP *entry;
    LIST_MSG *message;

    if(list_is_empty(list_head)){
        printf("list head is empty\n");
        return;
    }

    if(num > MAX_READ_ENTRY){
        num = MAX_READ_ENTRY;
    }
    printf("read message is :\n");
    for(entry = list_head->next; (entry != list_head) && (num > 0); entry = list_head->next){
        message = GET_ADDR_BY_OFFSET(entry, LIST_MSG, list);
        if(message){
            printf("%d\t", message->data);
            list_del(&(message->list));
            free(message);
            num--;
        }
    }
    printf("\n");
}

void *send_message_pth1(void *arg)
{
    int i = 0;
    MODULE_STRUCT *main_data;
    main_data = (MODULE_STRUCT *)arg;
    while(1){
        pri_spin_lock(&(main_data->spin_flag));
        add_data_tail(i, &(main_data->list_head));
        printf("-------IN SEDN MESSAGE PTHREAD 1 ------\n");
        pri_spin_unlock(&(main_data->spin_flag));
        i++;
        sleep(2);
    }
}

void *send_message_pth2(void *arg)
{
    int i = 0;
    MODULE_STRUCT *main_data;
    main_data = (MODULE_STRUCT *)arg;
    while(1){
        pri_spin_lock(&(main_data->spin_flag));
        add_data_tail(i, &(main_data->list_head));
        printf("--------IN SEDN MESSAGE PTHREAD 2----------\n");
        pri_spin_unlock(&(main_data->spin_flag));
        i++;
        sleep(2);
    }
}

void *print_message_pth(void *arg)
{
    MODULE_STRUCT *main_data;
    main_data = (MODULE_STRUCT *)arg;
    while(1){
        pri_spin_lock(&(main_data->spin_flag));
        printf("--------IN PRINT MESSAGE PTHREAD---------\n");
        print_data(&(main_data->list_head));
        pri_spin_unlock(&(main_data->spin_flag));
        sleep(2);
    }
}

void *read_message_pth(void *arg)
{
    int num = 5;
    MODULE_STRUCT *main_data;
    main_data = (MODULE_STRUCT *)arg;

    while(1){
        pri_spin_lock(&(main_data->spin_flag));
        printf("-------IN READ MESSAGE PTHREAD---------\n");
        read_data(&(main_data->list_head), num);
        pri_spin_unlock(&(main_data->spin_flag));
        sleep(3);
    }
}

int main(int argc, char *argv[])
{
    int i = 0;
    MODULE_STRUCT main_data;
    pthread_t pth1;
    pthread_t pth2;
    pthread_t pth3;
    pthread_t pth4;

    main_data.spin_flag = 1;
    init_list_head(&(main_data.list_head));
    for(i = 0; i < 10; i++){
        pri_spin_lock(&(main_data.spin_flag));
        add_data_tail(i, &(main_data.list_head));
        pri_spin_unlock(&(main_data.spin_flag));
    }

    if(pthread_create(&pth1, NULL, (void *)send_message_pth1, (void *)&main_data)){
        printf("create pthread failed\n");
        return -1;
    }
    if(pthread_create(&pth2, NULL, (void *)send_message_pth2, (void *)&main_data)){
        printf("create pthread failed\n");
        return -1;
    }
    if(pthread_create(&pth3, NULL, (void *)print_message_pth, (void *)&main_data)){
        printf("creat pthread failed\n");
        return -1;
    }
    if(pthread_create(&pth4, NULL, (void *)read_message_pth, (void *)&main_data)){
        printf("create pthread failed\n");
        return -1;
    }
    while(1)
    return 0;
}
viewsky11
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VC++6.0 动态链表源程序示例
04-21
通过这个“VC++6.0 动态链表源程序示例”，你可以学习如何在实际编程中实现和管理动态链表，这对于理解和处理复杂数据结构的程序设计至关重要。同时，这也有助于你在后续的学习中更好地理解其他高级数据结构，如双向...
C语言链表的例子程序
03-31
printf("请输入链表初始结点数:"); scanf("%d",&count); printf("请输入各个结点数值，每输入一个按回车确认：\n"); L = CreateList_L(L, count); system("cls"); ListDisp_L(L); system("PAUSE"); continue...
stdlib.h和stdio.h有什么区别
weixin_47887421的博客
10-07 5315
一、定位不同 1、stdlib.h是standard library标准库头文件，定位在通用工具函数。 2、stdio.h是standard input&output标准输入输出头文件，定位在标准的输入输出工具函数。 二、封装函数不同 1、stdlib.h主要封装了malloc()、calloc()、realloc()、free()、system()、atoi()、atol()、rand()、srand()、exit()等函数。 2、stdio.h主要封装了getchar()、putcha
C语言其他头文件
qq_66954747的博客
04-23 1299
C语言其他头文件 点击此处查看C语言所有头文件 🔑 以下内容只做简单介绍，想看详细介绍可进cplusplus网页文档自行查看 ✨常用头文件 stdio.h: 标准的输入输出头文件 int sprintf_s( char* const B, size_t const BCount,char const* const _Format,...) int sscanf_s(char const* const B,char const* const F, ...) string.h: 字符处理头文件
C语言 链表 简单案例
m0_56051805的博客
04-19 907
C语言 链表 简单案例
链表（实例）
w838325636的博客
04-15 3070
链表的概念 概念：链表是一种物理存储结构上不连续、非顺序的存储结构，数据元素逻辑顺序是通过l链表中的指针链接次序实现的。 分类 单向、双向 带头、不带头 循环、非循环 单项带头不循环链表操作 定义 typedef struct Node{ int value; struct Node* next; }Node; 初始化 void SListInit(Node* h...
c语言简单链表程序例子,静态链表基本操作（C语言详解）
weixin_39554170的博客
05-17 280
上节，我们初步创建了一个静态链表，本节学习有关静态链表的一些基本操作，包括对表中数据元素的添加、删除、查找和更改。本节是建立在已能成功创建静态链表的基础上，因此我们继续使用上节中已建立好的静态链表学习本节内容，建立好的静态链表如图 1 所示：图 1 建立好的静态链表静态链表添加元素例如，在图 1 的基础，将元素 4 添加到静态链表中的第 3 个位置上，实现过程如下：从备用链表中摘除一个节点，用于存...
java中使用双向链表实现贪吃蛇程序源码分享
09-03
以下是对如何使用Java中的双向链表来构建贪吃蛇程序的详细解释。 首先，我们来看链表节点（SnakeNode）的定义。这个类是链表的基本构建块，它包含了两个整型变量`x`和`y`，分别表示节点在网格中的位置。此外，每个...
c++链表排序程序示例
01-13
本示例着重介绍如何使用C++的类和结构体指针来实现链表的原地排序，即不创建新的链表而是直接在原有的链表上进行排序。 首先，我们需要定义一个链表节点的结构体，通常包括数据成员和指向下一个节点的指针： ```...
链表程序示例
03-29
本示例程序将深入探讨链表的基本操作，包括创建、查找、插入和删除节点。 1. **链表的创建** 创建链表涉及初始化头节点，头节点是链表的第一个元素，通常设置为null。在C++或Java等语言中，可以定义一个节点结构体...
用链表实现一个简单的通讯录管理系统
10-13
摘 要 本课程设计主要解决对于个人的通讯录，对同学，朋友信息进行管理的问题，通过建立一个相容，一致，易查的同学信息管理系统，实现对好友信息的插入，删除，显示和查询。在本课程设计中，系统开发平台为Windows2000,程序设计语言为C++，程序运行平台为Windws 98/2000/XP。在程序设计中采用了单链表和文件相结合的方法实现对学生成绩管理。程序通过调试运行，初步实现了设计目标，并且经过适当完善后，将可以应用在实际中解决问题。 关键词 程序设计；通讯录； C++；单链表
链表的基础运用
03-30
c语言中的链表和线性表的结合，初步掌握线性表的运用，合理进行编程
单链表C程序示例
02-27
这是一个在VC++6.0环境下写的关于单链表的C语言程序，包括单链表的创建，长度计算，打印，增加节点，删除节点等子函数。 适合初学者。
c语言链表示例
shengnan89的博客
05-09 2298
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。 链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。 说到这里你应该就明白了，链表就如同车链子一样，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素，该
单链表的构造和使用
c_shell_python的博客
03-05 861
单链表   链表可用于存储数据，在嵌入式开发时会经常用到，下面使用以前做过的例子记录一下数据结构中单链表的实现的增删改查。 #include &lt;stdlib.h&gt; #include &lt;stdio.h&gt; //初始化结构体 typedef struct linklist{ int id;//信息 struct linklist *next; //指针域 }Node...
Linux 内核“共享”双向链表(高逼格代码)
最新发布
qq_35803412的博客
08-08 176
/一． web 服务器超时的链表结构 typedef struct {int fd;// 使用超时时刻的时间戳表示 } ConnTimeout;} //二．璀璨星空的链表结构 typedef struct {int x;//星星的 x 坐标 int y;//星星的 y 坐标 enum STATUS stat;//状态 unsigned radius;//星星的半径 int step;//每次跳跃的间隔 int color;//星星的颜色 } STAR;}...
单链表操作实例程序
hero
07-30 1345
#include #include using namespace std; typedef struct node { int val; node *next; }node; node * create_list(); void traverse_list(node *pHead); int get_len_list(node *pHead); bool delete_list(no
单链表构成及其示例
qq_36551426的博客
10-05 622
在日常中出现需要存储一串数据的情况时，我们的第一反应就是想到运用数组。   单链表的背景及与数组的优劣势对比。 数组有其独特的优势，数组声明后便在内存中随机分配一片连续的，大小为Arry_length*sizeof (elem_type)的内存空间。单位数据占用空间小，在查找过程中，查找规则简单方便，效率高。其劣势也比较明显，若内存内没有满足条件的连续的内存空间，则无法分配内存。而计算机中的
数据结构例程——单链表应用举例
迂者-贺利坚的专栏
09-11 5962
　　本文针对数据结构基础系列网络课程(2)：线性表中第11课时单链表应用举例。 例：拆分单链表 （linklist.h是单链表“算法库”中的头文件，详情单击链接…） //本程序严格讲有个bug，详见1楼 #include &lt;stdio.h&gt; #include &lt;malloc.h&gt; #include "linklist.h" void split(LinkList *...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值