LinuxC应用开发学习笔记（五）--数据结构

最新推荐文章于 2024-08-12 00:58:13 发布
最新推荐文章于 2024-08-12 00:58:13 发布
阅读量788 收藏 1
点赞数
分类专栏： Linux操作系统 C语言 文章标签： 数据结构 链表 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46152793/article/details/121892682
版权

6、双向链表

双向链表的头文件
#ifndef LLIST_H_
#define LLIST_H_

/*百搭的数据结构*/
typedef void LLIST;
/*首部插入*/
#define LLIST_FORWARD   1
/*尾部插入*/
#define LLIST_BACKWARD  2

/*抽象出来的函数,函数类型为llist_op*/
typedef void llist_op(const void *);

/*抽象出来的函数,函数类型为llist_cmp*/
typedef int llist_cmp(const void *,const void *);

struct llist_node_st
{   
    struct llist_node_st *prev;
    struct llist_node_st *next;
    /*变长结构体的实现,做一个占位符,使用结构体类型的变量来引用*/
    char data[1];
};

typedef struct llist_head
{
    int size;
    struct llist_node_st head;
    
    int  (*insert)(struct llist_head *,const void *,int);
    
    void *(*find)(struct llist_head *,const void *,llist_cmp *);
    
    int  (*delete)(struct llist_head *,const void *,llist_cmp *);
    
    int  (*fetch)(struct llist_head *,const void *,llist_cmp *,void *);
    
    void (*travel)(struct llist_head *,llist_op *);
}LLIST;


/*双向链表的创建*/
LLIST* llist_create(int initsize);
/*双向链表的插入*/
int llist_insert(LLIST *,const void *data,int mode);
/*双向链表的查找*/
void  *llist_find(LLIST *,const void *key,llist_cmp *);
/*双向链表的删除*/
int llist_delete(LLIST *,const void *key,llist_cmp *);
/*双向链表的元素获取*/
int llist_fetch(LLIST *,const void *key,llist_cmp *,void *data);
/*双向链表的遍历*/
void llist_travel(LLIST *,llist_op *);
/*双向链表的销毁*/
void llist_destory(LLIST *);
#endif // !LLIST_H_
双向链表的C文件
#include  <stdio.h>
#include  <stdlib.h>
#include <string.h>
#include "llist.h"

/**
  * @brief  双向链表的创建
  * @param  创建大小
  * @retval 创建的双向链表的首地址
  */
LLIST* llist_create(int initsize)
{

	 /*双向链表头结点*/
    LLIST *new;
    new = malloc(sizeof(*new));
    if (new == NULL)
        return NULL;
		/*双向链表的大小*/
    new->size = initsize;
    /*初始化双向链表的前驱结点*/
    new->head.prev = &new->head;
    /*初始化双向链表的后继结点*/
    new->head.next = &new->head;
    
	 /*使用函数指针操作,函数名传递的是函数的首地址*/
	 /*给当前指针做一个赋值*/
    new->insert = llist_insert;
    
    new->delete = llist_delete;
    
    new->find   = llist_find;
    
    new->fetch  = llist_fetch;
    
    new->travel = llist_travel;
    
    return new;
}

/**
  * @brief  双向链表的插入
  * @param  链表名,插入数据,插入模式
  * @retval 双向链表的插入状态
  */
int llist_insert(LLIST *p,const void *data,int mode)
{
    struct llist_node_st *newnode;
    struct llist_node_st *ptr = p;   
    /*结构体大小再加上ptr->size*/
    newnode = malloc(sizeof(*newnode)+ptr->size);
    if (newnode == NULL)
        return -1;
   
		/*往newnode->data位置拷贝ptr->size字节的data数据*/
    memcpy(newnode->data,data,ptr->size);
    if(newnode->data == NULL)
    	   return -2;
   
	/*首部插入模式*/
    if (mode == LLIST_FORWARD)
    {
    		 /*新前驱结点的前驱结点为头结点*/
        newnode->prev = &ptr->head;
        /*新结点的后继结点为头结点的next*/
        newnode->next = ptr->head.next;   
    }
    
    /*尾部插入模式*/
    else if(mode == LLIST_BACKWARD)
    {
    		 /*新结点的前驱结点为头结点的前驱结点*/
        newnode->prev = ptr->head.prev;
        /*新结点的next指向头结点*/
        newnode->next = &ptr->head;    
    }
    /*错误*/
    else
    {
        return -3;
    }
    		/*当前结点的前驱后继等于结点本身*/
        newnode->prev->next = newnode;
       /*当前结点的后继前驱等于结点本身*/
        newnode->next->prev = newnode;
    return 0;
}

/**
  * @brief  双向链表的查找子函数
  * @param  链表起始位置,关键字,比较函数
  * @retval 无（数据类型不统一,使用万能的void,使得函数具有通用性）
  */
static struct llist_node_st *find_(struct llist_node_st *ptr,const void *key,llist_cmp*cmp)
{
    struct llist_node_st *cur;
    for (cur = ptr->head.next;cur!= &ptr->head;cur=cur->next)
    {
    		/*比较数值是否相同*/
       if(cmp(key,cur->data)==0)
        break;
    }
    return cur;
}

/**
  * @brief  双向链表的查找
  * @param  链表名
  * @retval 无（数据类型不统一,使用万能的void,使得函数具有通用性）
  */
void  *llist_find(LLIST *p,const void *key,llist_cmp *cmp)
{
		/**/
    struct llist_node_st *node;
    struct llist_node_st *ptr = p;
    node = find_(ptr,key,cmp);
    /*如果是当前的头结点*/
    if (node == &ptr->head)
        return NULL;
    return node->data;
}

/**
  * @brief  双向链表的销毁
  * @param  链表名,删除元素名,比较函数
  * @retval 删除状态
  */
int llist_delete(LLIST *p,const void *key,llist_cmp *cmp)
{
    struct llist_node_st *node;
    struct llist_node_st *ptr = p;
    /*根据key查找,使用node接收*/
    node = find_(ptr,key,cmp);
    if (node == &ptr->head)
        return -1;
    node->prev->next = node->next;
    node->next->prev = node->prev;
    /*释放node*/
    free(node);
    return 0;
}

/**
  * @brief  双向链表的内容的删除并且拿回
  * @param  链表名
  * @retval 操作状态
  */
int llist_fetch(LLIST *p,const void *key,llist_cmp *cmp,void *data)
{
    struct llist_node_st *node;
    struct llist_node_st *ptr = p;
    node = find_(ptr,key,cmp);
    /*拿到的是头结点,返回失败*/
    if (node == &ptr->head)
        return -1;
    /*脱链的过程*/
    node->prev->next = node->next;
    node->next->prev = node->prev;
    if (node != NULL)
    {
    		/*给data的ptr->size填充node->data*/
        memcpy(data,node->data,ptr->size);
    }
    free(node);
    return 0;
}

/**
  * @brief  双向链表的遍历
  * @param  链表名
  * @retval 无
  */
void llist_travel(LLIST *p,llist_op *op)
{
    struct llist_node_st *cur;
    struct llist_node_st *ptr = p;
    /*cur等于头结点的next,跳过头结点*/
    for (cur = ptr->head.next;cur!=&ptr->head;cur=cur->next)
    {
    		/*用户回调函数,程序具有通用性,用户自行编写*/
        op(cur->data);
    }
}
/**
  * @brief  双向链表的销毁
  * @param  链表名
  * @retval 无
  */
void llist_destory(LLIST *p)
{
    struct llist_node_st *cur,*next;
    struct llist_node_st *ptr = p;
    /*cur指向第一个有效结点,cur不能等于&ptr->head,如果等于说明转过了一圈*/
    for (cur = ptr->head.next;cur != &ptr->head;cur=cur->next)
    {
    		 /*next保存当前结点的下一个结点*/
        next = cur->next;
        free(cur);
    }
    /*释放头结点*/
    free(ptr);
}

P93 C语言实现C++的面向对象

双向链表的主函数

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

#define NAMESIZE 32
struct score_st
{
    int id;
    char name[NAMESIZE];
    int math;
    int chinese;
};

/*用户自定义的回调函数*/
void printf_s(const void *record)
{
		/*类型转换*/
    const struct score_st *r = record;
    
    printf("""%d %s %d %d \n",r->id,r->name,r->math,r->chinese);    
};

/*用户自定义的比较回调函数*/
static int id_cmp(const void *key,const void *record)
{
		/*数据类型转换*/
    const int *k = key;
    /*数据类型转换*/
    const struct score_st *r = record;
    /*返回值是一个状态*/
    return (*k-r->id);
}

/*用户自定义的回调函数,设置为字符串比较函数*/
static int name_cmp(const void *key,const void *record)
{
	 /*参数类型的转换*/
    const char*k = key;
     /*参数类型的转换*/
    const struct score_st *r = record;  
    /*字符串比较函数*/  
    return strcmp(k,r->name);
}

int main()
{
    struct score_st tmp;
    int ret;
    LLIST *handler;
    handler =  llist_create(sizeof(struct score_st));
    if (handler == NULL)
            exit(1);
            
    for (int  i = 0; i < 7; i++)
    {
        tmp.id = i;
        snprintf(tmp.name,NAMESIZE,"std%d",i);
        tmp.math = rand()%100;
        tmp.chinese = rand()%100;
        /*调用函数并且给函数传参*/
        ret = handler->insert(handler,&tmp,LLIST_BACKWARD);
        if (ret)
            exit(1);     
    }
		/*使用面向对象方式调用*/
    handler->travel(handler,printf_s);

    printf("\n\n");
	 /*测试删除函数*/
    int id = 3;
    char *del_name = "std6";
    ret = llist_delete(handler,del_name,name_cmp);
    if (ret)
        printf("llist_delete failed\n");
    llist_travel(handler,printf_s);

		/*测试find函数*/
    struct score *data;
    data = llist_find(handler,&id,id_cmp);
    if (data == NULL)
        printf("can't find !\n");
    else 
        printf_s(data); 
    llist_destory(handler);
    exit(0);
}

7、内核源码实现双向链表

双向链表的头文件
#ifndef  LINUX_LIST_H__
#define  LINUX_LIST_H__

struct list_head
{
    struct list_head *prev;
    struct list_head *next;
};

#define  LIST_HEAD_INIT(name) {&(name),&(name)}
#define LIST_HEAD(name)  struct list_head name = LIST_HEAD_INIT(name)
static inline void __list_add(struct list_head *new,
                                struct list_head *prev,
                                struct list_head *next)
{
    next->prev = new;
    new->next = next;
    new->prev = prev;
    prev->next = new;
}

static inline void list_add(struct list_head *new,struct list_head *head)
{
    __list_add(new,head,head->next);
}

#define __list_for_each(pos,head)\
    for (pos = (head)->next;pos!= (head);pos = pos->next)
    
/*
* ptr->cur;
* type->struct score_st;
* member->node
*/

#define  offsetof(TYPE,MEMBER)  ((size_t)&((TYPE *)0)->MEMBER)
#define container_of(ptr,type,member)\
    ({ (type *)((char *)ptr - offsetof(type,member));})
#define list_entry(ptr,type,member)\
        container_of(ptr,type,member)

#endif
双向链表的主函数
#include <stdlib.h>
#include <stdio.h>
#include "list.h"

#define NAMESIZE 32

struct score_st
{
    int id;
    char name[NAMESIZE];
    struct list_head node;
    int math;
    int chinese;
};

static void printf_s(struct score_st *d)
{
    printf("%d %s %d %d\n",d->id,d->name,d->math,d->chinese);
}

int main()
{
    struct score_st *datap;
    struct list_head *cur;
    LIST_HEAD(head);
    for (int  i = 0; i < 7; i++)
    {
        datap = malloc(sizeof(*datap));
        if (datap == NULL)
            exit(1);
        datap->id = i;
        snprintf(datap->name,NAMESIZE,"stu%d",i);
        datap->math = rand()%100;
        datap->chinese = rand()%100;
    
        list_add(&datap->node,&head);
    }
        
    __list_for_each(cur,&head)
    {
        datap =  list_entry(cur,struct score_st,node);
        printf_s(datap);
    }
     __list_for_each(cur,&head)
    {
        datap =  list_entry(cur,struct score_st,node);
        if (datap->id == 5)
        {
            break;
        } 
    }
    if (cur == &head)
        printf("can't find");
    else
        printf_s(datap);
    exit(0);
}

8、栈的实现（线性表）

栈实现的头文件
#ifndef SQSTACK_H__
#define SQSTACK_H__

#define MAXSIZE 5

typedef int datatype;

typedef struct node_st
{
    datatype data[MAXSIZE];
    /*记录栈顶的位置*/
    int top;
}sqstack;
/*栈的创建*/
sqstack *st_create(void);
/*判断栈是否为空*/
int st_isempty(sqstack*);
/*入栈*/
int st_push(sqstack*,datatype *);
/*出栈*/
int st_pop(sqstack*,datatype *);
/*获取栈顶元素*/
int st_top(sqstack*,datatype *);//fetch top element;
/*栈的遍历*/
void st_travel(sqstack*);
/*栈的销毁*/
void st_destory(sqstack *);
#endif // !SQSTACK_H__
栈实现的C文件
#include <stdlib.h>
#include <stdio.h>
#include "sqstack.h"
/**
  * @brief  栈的创建
  * @param  None
  * @retval 栈的起始位置
  */
sqstack *st_create(void)
{
    sqstack *st;
    st = malloc(sizeof(*st));
    if (st == NULL)
          return NULL;
	/*配置栈顶元素为-1*/
    st->top = -1;
    return st;
}

/**
  * @brief  判断栈是否为空
  * @param  栈的起始位置
  * @retval 1表示为空,0表示非空
  */
int st_isempty(sqstack* st)
{
    return (st->top == -1);  
}

/**
  * @brief  入栈
  * @param  栈的起始位置,入栈元素
  * @retval -1表示失败,0表示成功
  */
int st_push(sqstack* st ,datatype *data)
{
	 /*栈已满*/
    if (st->top == MAXSIZE - 1)
    {
        return -1;
    }
     /*栈的下一个元素存放data*/
    st->data[++st->top]  =  *data;
    return 0;
}

/**
  * @brief  出栈
  * @param  栈的起始位置,出栈元素
  * @retval 1表示为空,0表示非空
  */
int st_pop(sqstack*st,datatype *data)
{
		/*判断栈是否为空*/
    if (st_isempty(st))
        return -1;
    /*指向栈顶的下一个元素*/
    *data = st->data[st->top --];
    return 0; 
}

/**
  * @brief  取栈顶元素
  * @param  栈的起始位置,出栈元素
  * @retval -1表示失败,0表示成功
  */
int st_top(sqstack*st,datatype *data)//fetch top element;
{
		/*判断栈是否为空*/
     if (st_isempty(st))
    {
        return -1;
    }
    *data = st->data[st->top];
    return 0;
}

/**
  * @brief  栈的遍历
  * @param  栈的起始位置
  * @retval None
  */
void st_travel(sqstack* st)
{
		/*判断栈是否为空*/
    if (st_isempty(st))
    return ;
    /*循环遍历栈内元素*/
    for (int i = 0; i <= st->top; i++)
    {
        printf("%d \n",st->data[i]);
    }
    printf("\n");
}

/**
  * @brief  栈的销毁
  * @param  栈的起始位置
  * @retval None
  */
void st_destory(sqstack * st)
{
    free(st);  
}
栈实现的主函数
#include <stdlib.h>
#include <stdio.h>
#include "sqstack.h"

int main()
{
    datatype arr[] = {19,23,45,67};
    sqstack *st;
    st = st_create();
    if (st == NULL)
        exit(1);
    /*栈的初始化*/
    for (int  i = 0; i < sizeof(arr)/sizeof(*arr); i++)
    {
        st_push(st,&arr[i]);
    }
		/*栈的遍历*/
    st_travel(st);
	  
    datatype tmp;
    while (st_pop(st,&tmp) == 0)
    {
        printf("POP: %d\n",tmp);
    }
    /*出栈测试*/
    datatype tmp = 1;
    int ret;
    ret = st_push(st,&tmp);
    if (ret != 0)
        printf("st_push failed.\n");
    else
        st_travel(st);
    st_destory(st);
}

9、栈的实现（链表）

栈实现的头文件
#ifndef STACK_H__
#define STACK_H__
#include "llist.h"

typedef LLIST STACK;
/*栈的创建*/
STACK *stack_create(int initsize);
/*入栈*/
int stack_push(STACK * ,const void*);
/*出栈*/
int stack_pop(STACK * ,void *);
/*销毁栈*/
void stack_destory(STACK *);
#endif // !STACK_H__
栈实现的C文件

#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
/**
  * @brief  栈的创建
  * @param  栈的大小
  * @retval 栈的起始地址
  */
STACK* stack_create(int initsize)
{
		/*通过链表创建栈*/
   return llist_create(initsize);
}

/**
  * @brief  入栈
  * @param  栈名,入栈内容
  * @retval 入栈的状态
  */
int stack_push(STACK *ptr ,const void*data)
{
    return llist_insert(ptr,data,LLIST_FORWARD);
}

/**
  * @brief  静态定义完全匹配函数
  * @param  任意匹配的参数1,任意匹配的参数2
  * @retval None
  */
static int always_match(const void *p1,const void *p2)
{
    return 0;
}

/**
  * @brief  出栈
  * @param  栈的起始位置,出栈元素
  * @retval 出栈状态
  */
int stack_pop(STACK *ptr ,void *data)
{
    return llist_fetch(ptr,(void *)0,always_match,data);
}

/**
  * @brief  栈的销毁
  * @param  栈的首地址
  * @retval None
  */
void stack_destory(STACK *ptr)
{
    llist_destory(ptr);
}
栈实现的主函数
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"

#define NAMESIZE 32

int ret;

struct score_st
{
    int id;
    char name[NAMESIZE];
    int math;
    int chinese;
};
/*打印函数,打印出栈的元素*/
static void  printf_s(void *record)
{
    struct score_st *r = record;
    printf("%d %s %d %d \n",r->id,r->name,r->math,r->chinese);
}

int main()
{
    STACK *st;
    
    struct score_st tmp;
    
    st =  stack_create(sizeof(struct score_st));
    if (st == NULL)
       exit(1);
    for (int i = 0; i < 7; i++)
    {   
        tmp.id = i;
        snprintf(tmp.name,NAMESIZE,"std%d",i);
        tmp.math = rand()%100;
        tmp.chinese = rand()%100;
        /*如果入栈异常*/
        if(stack_push(st,&tmp))
        			exit(1);
    }
    
    while (1)
    {
    		 
        ret =  stack_pop(st,&tmp);
        /*如果出栈异常,跳出*/
        if (ret == -1)
            break;
        printf_s(&tmp);
    }
    stack_destory(st);
    exit(0);
}

10、队列的实现（线性表）

队列实现的头文件
#ifndef QUEUE__H_
#define QUEUE__H_
#define MAXSIZE 5
typedef int datatype;

typedef struct node_st
{
    datatype data[MAXSIZE];
    int head,tail;
}queue;

/*队列的创建*/
queue *qu_create();
/*判断队列是否为空*/
int qu_isempty(queue *);
/*队列的入队*/
int qu_enqueue(queue*,datatype *);
/*队列的出队*/
int qu_dequeue(queue*,datatype *);
/*队列的遍历*/
void qu_travel(queue*);
/*队列的清除*/
void qu_clear(queue*);
/*队列的销毁*/
void qu_destory(queue *);

#endif // !QUEUE__H_
队列实现的C文件
#include <stdlib.h>
#include <stdio.h>
#include "queue.h"

/**
  * @brief  队列的创建
  * @param  None
  * @retval 队列的首地址
  */
queue *qu_create()
{
    queue*sq;
    sq = malloc(sizeof(*sq));
    if (sq == NULL)
    {
        return NULL;
    }
    sq->head = 0;
    sq->tail = 0;
    return sq;
}

/**
  * @brief  判断队列是否为空
  * @param  队列的首地址
  * @retval 1表示为空,0表示非空
  */
int qu_isempty(queue *sq)
{
    return (sq->head == sq->tail);
}

/**
  * @brief  队列的入队
  * @param  队列的首地址,入队元素
  * @retval 入队状态
  */
int qu_enqueue(queue*sq,datatype *x)
{
    if ((sq->tail+1)%MAXSIZE == sq->head)//如果尾巴取余+1等于头，那么不可以加入。
        return -1;
    /*队列的尾巴等于队列的尾巴+1 和 队列最大值取余*/
    sq->tail = (sq->tail +1) % MAXSIZE;
    /*入队元素就是待入队的元素*/
    sq->data[sq->tail] = *x;
    return 0; 
}

/**
  * @brief  队列的出队
  * @param  队列的首地址,出队元素
  * @retval 出队状态
  */
int qu_dequeue(queue*sq,datatype *x)
{
		/*判断队列是否为空*/
    if(qu_isempty(sq))
            return -1;    
    /*队列的头等于队列的头+1 和 队列最大值取余表示队列的起始位置*/
    sq->head = (sq->head+1)%MAXSIZE;
    /*出队元素就是队列的头*/
    *x = sq->data[sq->head];
    return 0;
}

/**
  * @brief  队列的遍历
  * @param  队列的首地址
  * @retval None
  */
void qu_travel(queue*sq)
{
		/*判断队列是否合法*/
    if (sq->head == sq->tail)
        return ;
    /*队列的起始位置*/
    int i = (sq->head + 1)%MAXSIZE;
    /*头部结点不等于尾部结点时*/
    while (i!=sq->tail)
    {
    		/*打印每一个结点*/
        printf("%d ",sq->data[i]);
        /*队列位置递增*/
        i = (i+1)%MAXSIZE;
    }
    /*打印最后一个结点*/
    printf("%d \n",sq->data[i]);  
}

/**
  * @brief  队列的清空
  * @param  队列的首地址
  * @retval None
  */
void qu_clear(queue*sq)
{
		/*让队列的头部指向队列的尾巴*/
    sq->head = sq->tail;
}

/**
  * @brief  队列的销毁
  * @param  队列的首地址
  * @retval None
  */
void qu_destory(queue *sq)
{
    free(sq);   
}
队列实现的主函数
#include <stdlib.h>
#include <stdio.h>
#include "queue.h"

int main()
{
    queue *sq;
    datatype arr[] = {2,3,98,12};
    int i,ret;
    /*队列的创建*/
    sq = qu_create();
    if (sq == NULL)
        exit(1);
    /*队列的初始化*/
    for (int  i = 0; i < sizeof(arr)/sizeof(*arr); i++)
    {
        qu_enqueue(sq,&arr[i]);
    }    
    /*队列的遍历*/
    qu_travel(sq);
    
    /*队列入队的测试*/
    datatype tmp = 100;
    ret = qu_enqueue(sq,&tmp);
    if (ret == -1)
        printf("queue is full!\n");
    else
        qu_travel(sq);
		/*队列的出队测试*/
    datatype tmp;
    qu_dequeue(sq,&tmp);
    printf("DEQUEUE: %d \n",tmp);
    /*队列的遍历*/
    qu_travel(sq);
    /*队列的销毁*/
    qu_destory(sq);
    exit(0);
}

11、队列的实现（链表）

链表实现的头文件
#ifndef QUEUE__H_
#define QUEUE__H_
#include "llist.h"

typedef LLIST QUEUE;
/*队列的创建*/
QUEUE *queue_create(int);
/*队列入队*/
int queue_en(QUEUE *,const void * );
/*队列出队*/
int queue_de(QUEUE *,void *);
/*队列销毁*/
void queue_destory(QUEUE *);
#endif //  QUEUE__H_
链表实现的C文件
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"

/**
  * @brief  队列创建
  * @param  队列的大小
  * @retval 队列的首地址
  */
QUEUE * queue_create(int size)
{
    return llist_create(size);
}

/**
  * @brief  队列的入队
  * @param  队列的首地址,入队元素
  * @retval 入队状态
  */
int queue_en(QUEUE *ptr,const void * data)
{
    return llist_insert(ptr,data,LLIST_BACKWARD);
}

/**
  * @brief  完全匹配函数
  * @param  通用类型 p1,p2
  * @retval 0
  */
static int  alwaws_match(const void *p1 ,const void *p2)
{
    return 0;
}

/**
  * @brief  队列的出队
  * @param  队列的首地址,出队数据
  * @retval None
  */
int queue_de(QUEUE *ptr,void *data)
{
    return llist_fetch(ptr,(void*)0,alwaws_match,data);
}

/**
  * @brief  队列的销毁
  * @param  队列的首地址
  * @retval None
  */
void queue_destory(QUEUE *ptr)
{
    llist_destory(ptr);
}
链表实现的主函数
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"

#define MAXSIZE 32
struct score_st
{
    int id;
    char name[MAXSIZE];
    int math;
    int chinese;
};

/*自定义打印函数,参数为通用void*类型*/
static void printf_s(void *record)
{
    struct score_st *r = record;
    printf("%d %s %d %d \n",r->id,r->name,r->math,r->chinese);
}

int main()
{
    QUEUE *qu;
    int ret;
    struct score_st tmp;
    /*队列的创建*/
    qu = queue_create(sizeof(struct score_st));
        if (qu == NULL)
            exit(1);  
    for (int  i = 0; i < 7; i++)
    {
        tmp.id = i;
        snprintf(tmp.name,MAXSIZE,"stu%d",i);
        tmp.math = rand()%100;
        tmp.chinese = rand()%100;
        
        /*判断队列入队是否发生错误*/
        if(queue_en(qu,&tmp)!=0)
            break;
    }
     
    /*队列执行出队操作*/
    while (1)
    {
        ret =  queue_de(qu,&tmp);
        if (ret == -1)
            break;
        printf_s(&tmp);
    }
    /*队列的销毁*/
    queue_destory(qu);
    exit(0);
}
梅山剑客
关注
专栏目录
Linux C 数据结构——栈
知秋一叶
12-28 2105
栈是限制在一段进行插入操作和删除操作的线性表（俗称堆栈），允许进行操作的一端称为“栈顶”，另一固定端称为“栈底”，当栈中没有元素称为“空栈”。特点：先进后出（FILO）。 栈顶即top，这里top有两种定义方式： 1、满栈（Full Stack）,top指向最后一个使用的空间； 2、空栈（Empty Stack），top指向下一个可用的空间；      栈也是线性表，所以也分顺序存储和
Linux C 数据结构---线性表
知秋一叶
12-24 2084
数据结构指的是数据元素及数据元素之间的相互关系，包含下面三方面的内容：
数据结构（Linux环境C语言版）
铁路十六宿舍的博客
04-04 1237
本文通过大量嵌入式工程师可能会用到的示例，从实用的角度讲述了数据结构这门计算机核心课程的理念，帮助读者更好地理解数据结构在编程中的重要性。
数据结构1——linuxC（顺序表+单向链表）
天天的博客
02-16 351
​ 一。顺序表 #include <stdio.h> #define SEQ_SIZE 10 // 声明数据节点 struct seq_node{ int data; }; // 遍历显示顺序表所有有效数据 void seq_show(struct seq_node *seq_list); // 将该正数存放到顺序表中 void seq_add(int new_data, struct seq_node *seq_list); // 将该数从顺序表中删除 void seq_del(int
c语言中的数据结构，顺序表、链表（Linux内核链表）
hqb_newfarmer的博客
02-22 293
c语言中的数据结构，顺序表、链表（Linux内核链表）
C、C++、Qt、Linux、ARM、数据结构等学习笔记.zip
06-16
在本压缩包“C、C++、Qt、Linux、ARM、数据结构等学习笔记.zip”中，包含了多种编程语言及重要计算机科学领域的学习资源，尤其是针对数据结构这一核心概念的深入探讨。数据结构是计算机科学的基础，对于理解和解决...
嵌入式全栈开发学习笔记---项目1：停车管理系统
最新发布
xiaobaivera的博客
08-12 1030
目前为止我们已经学习了linux系统的终端上的一些操作命令、vim编辑器上的一些操作命令、C语言和数据结构，接下来我们就用我们学过的这些知识做一个“停车管理系统”的项目。开发环境：基于VMware Workstation虚拟机上的Linux系统的终端上的vim编辑器。涉及重要知识点：C语言（二维数组）；数据结构（链表、队列、广度优先算法（BFS））；
linuxon-model-for-n开发笔记
06-13
"Linux on Model for N"的开发笔记主要关注的是如何在Linux环境下构建和优化网络相关的模型。在这个主题下，我们可以深入探讨以下几个关键知识点： 1. **Linux基础**：首先，理解Linux操作系统的基本原理和命令行...
Linux高并发服务器开发---笔记4（网络编程）
weixin_38665351的博客
07-20 3679
0705Linux高并发服务器开发—笔记1见Linux高并发服务器开发—笔记2见Linux高并发服务器开发—笔记3（多线程）视频课链接： 4.6 网络编程1 4.6 网络编程2计算机网络笔记 ②Linux简明系统编程（嵌入式公众号的课）—总课时12h 网卡是一块被设计用来允许计算机在计算机网络上进行通讯的计算机硬件，又称为网络适配器或网络接口卡NIC。其拥有 MAC 地址，属于 OSI 模型的第 2 层，它使得用户可以通过或相互连接。（即网卡分为以太网卡和无线网卡）每一个网卡都有一个被称为 MAC 地址的独
linux C数据结构类型
qy961212的博客
10-08 479
 1.C语言里面如何计算数据类型取值范围及其大小 类型说明符 数的范围 字节数 int -231~(231-1) 4 unsigned int 0～65535即0~(216-1) 4
数据结构之栈操作(linux C语言　带有菜单选择)
11-07
基于Linux操作系统应用C语言实现的数据结构之栈操作(带有菜单函数控制)，程序健壮性强。
Linux C 第九章 数据结构函数
SongYuLong
12-28 404
第九章 数据结构函数 #include <stdlib.h> #include <search.h>bsearch : void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int(*compar)(const void*, const void*));
数据结构-C语言
Linux
08-27 1059
什么是数据 描述客观事物的符号，是计算机中可以操作的对象， 是能被计算机识别，并输入给计算机处理的符号集合。 注意： # 数据有两个特点： 1. 可以输入给计算机 2. 能够被计算机程序处理 # 数据不仅仅包括整型、实型等数值类型， 还包括字符及声音、...
数据结构线性顺序表的Linux Ubuntu C语言实现
weixin_65155181的博客
07-28 587
以上就是线性顺序表在LinuxUbuntu下的C语言实现，功能还有很多，作者只是例举了常见的一部分，欢迎大家补充，一起交流学习。第一个元素没有前驱，最后一个元素没有后继，中间元素有唯一前驱，但是可以有多个后继。第一个元素没有前驱，最后一个元素没有后继，中间元素既有唯一前驱，也有唯一后继。①集合结构一个范围内，每一个个体之间没有任何关联。④图形结构多对多的关系，各个元素之间可能都有关联。特点每一个元素都会创建一张索引表，资源开销比较大，②线性结构一对一的关系，有唯一前驱和后继。......
Linux-C数据结构大小
legend050709的专栏
12-11 536
目录什么是字节对齐为什么要字节对齐基本类型及其大小结构体大小计算结构体大小的原则偏移量联合体的大小结构体中嵌套结构体结构体中嵌套联合体结构体中包含数组自定义n字节对齐范例参考 什么是字节对齐 现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定变量的时候经常在特定的内存地址访问，这就需要各类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个字节的排放，这就是对齐。 为什么要字节对齐 各个硬件平台对存储空间的处理上有很大的不同。 一
LinuxC应用开发学习笔记（七）--数据结构
梅山
12-16 705
栈和队列的应用–求中算法 主函数 #include <stdio.h> #include <stdlib.h> #include "sqstack.h" #include "queue.h" #define NR_BALL 27 static int check(queue *qu) { int i = (qu->head+1)%MAXSIZE; while (i!=qu->tail) { if(qu->data[i]&g
LinuxC应用开发学习笔记（四）--数据结构
梅山
12-08 1101
数据结构 1、线性表 线性表的头文件 #ifndef SQLIST_H__ #define SQLIST_H__ #define DATASIZE 1024 typedef int datatype; typedef struct node_st { datatype data[DATASIZE]; int last; /* data */ }sqlist; sqlist *sqlist_create(); void sqlist_creat1(sqlist **); i
linux操作系统：进程数据结构，项目多了就需要项目管理系统
OceanStar的博客
11-23 284
引入 linux内核是如何管理线程和进程的呢？ 有的进程只有一个线程，有的进程有多个线程，它们都需要内核分配CPU来干活。可是CPU个数是有限的，应该怎么管理，怎么调度呢？ 类比项目管理中，无论是大项目还是小项目，从项目经理的角度来看，这些都是任务 同样在linux里面无论是进程，还是线程，到了内核里面，统一叫做任务（Task），由一个统一的结构task_struct进行管理 接下来，我们沿着项目管理体系的思路，设想 ...
linux c排序算法
qq_36246937的博客
06-10 251
一、冒泡排序 基本思想：比较相邻的两个数，如果前者比后者大，则进行交换。每一轮排序结束，选出一个未排序中最大的数放到数组后面。 #include <stdio.h> #include <stdlib.h> int main() { int i, j, num[8] = {0}; printf("please input eight number: "); for( i = 0; i < 8; i++){ scanf("%d", &num[i]); }
Linux进程理解与嵌入式学习笔记
"进程与程序的区别，动态电压恢复器的补偿策略，Linux内核中的task_struct，进程状态转换，C语言，数据结构，Linux应用，Linux IO编程，进程线程编程，System V IPC" 在计算机科学中，进程与程序是两个重要的概念。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值