通用链表/栈/队列-算法学习笔记十六

最新推荐文章于 2022-07-20 18:08:24 发布
最新推荐文章于 2022-07-20 18:08:24 发布
阅读量527 收藏
点赞数
分类专栏： 数据结构&算法 文章标签： 链表 栈 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012785877/article/details/71036746
版权

今天准备学习数据结构-图，会用到栈和队列，因此写了下代码，底层用了通用链表，为循环双向结构，结点数据域为void *；通用链表层之上封装了栈和队列，比较简单，但是代码行数有点多，单独摘出：

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

#define MAX_VERTEX_NUM 1000

#define PRINT(format, arg...) \
do{ \
    printf("[%s/%d]:", __func__, __LINE__); \
    printf(format, ##arg); \
    printf("\n"); \
}while(0)

/*****************************底层链表***************************/
// 循环双向链表
typedef struct link_list_node {
    void *data;
    struct link_list_node *pre;
    struct link_list_node *next;
} link_list_node;
typedef struct link_list {
    int size;

    //链表插入函数
    void (*insert)( struct link_list *list, void *data );

    //链表取第一个结点
    void *(*get_first)( struct link_list *list );

    //链表取最后一个结点
    void *(*get_last)( struct link_list *list );

    //链表删除第一个结点
    void *(*del)( struct link_list *list );

    struct link_list_node *head;
} link_list;
link_list_node *create_link_list_node(
    void *data )
{
    link_list_node *node = NULL;

    node = ( link_list_node * )malloc( sizeof(link_list_node) );
    node->data = data;
    node->pre = NULL;
    node->next = NULL;

    return node;
}
//头插
void insert_head(
    link_list *list,
    void *data )
{
    if ( !list ) {
        PRINT("list is null.");
        return;
    }

    link_list_node *node = create_link_list_node( data );

    if ( !list->head ) {
        node->next = node;
        node->pre = node;
        list->head = node;
        list->size = 1;
        return;
    }

    node->next = list->head;
    node->pre = list->head->pre;
    list->head->pre->next = node;
    list->head->pre = node;
    list->head = node;

    list->size += 1;
}
//尾插，栈/队列的插入
void insert_tail (
    link_list *list,
    void *data )
{
    if ( !list ) {
        return;
    }

    link_list_node *node = create_link_list_node( data );

    if ( !list->head ) {
        node->next = node;
        node->pre = node;
        list->head = node;
        list->size = 1;
        return;
    }

    node->pre = list->head->pre;
    node->next = list->head;
    list->head->pre->next = node;
    list->head->pre = node;

    list->size += 1;
}
//获取链表头数据
void *get_head(
    link_list *list )
{
    if ( !list || !list->head ) {
        PRINT("list is null.");
        return NULL;
    }
    return list->head->data;
}
//获取链表尾数据
void *get_tail(
    link_list *list )
{
    if ( !list || !list->head ){
        PRINT("list is null.");
        return NULL;
    }
    return list->head->pre->data;
}
//删除链表头，并返回删除结点的数据
void *del_head(
    link_list *list )
{
    if ( !list || !list->head ) {
        return NULL;
    }

    if ( list->size == 1 ) {
        void *data = list->head->data;
        free( list->head );
        list->head = NULL;
        list->size = 0;
        return data;
    }

    link_list_node *p = list->head;
    void *data = p->data;

    list->head->pre->next = list->head->next;
    list->head->next->pre = list->head->pre;
    list->head = list->head->next;

    list->size -= 1;
    free( p );

    return data;
}
//删除链表尾，并返回删除结点的数据
void *del_tail(
    link_list *list )
{
    if ( !list || !list->head ) {
        PRINT("list is null.");
        return NULL;
    }

    if ( list->size == 1 ) {
        void *data = list->head->data;
        free( list->head );
        list->head = NULL;
        list->size = 0;
        return data;
    }

    link_list_node *p = list->head->pre;
    void *data = p->data;

    list->head->pre->pre->next = list->head;
    list->head->pre = list->head->pre->pre;

    list->size -= 1;
    free( p );

    return data;
}
/******************************************************************/

/********************************队列***********************************/
typedef struct queue {
    void *(*first)( struct queue *this );
    void *(*last)( struct queue *this );
    void (*enqueue)( struct queue *this, void *data );
    void *(*dequeue)( struct queue *this );
    int (*size)( struct queue *this );
    void (*free)( struct queue *this );
    struct link_list *list;
    struct queue *this;
} queue;
void *queue_get_first(
    queue *q )
{
    if ( !q || !q->list )
        return NULL;

    return q->list->get_first( q->list );
}
void *queue_get_last(
    queue *q )
{
    if ( !q || !q->list )
        return NULL;

    return q->list->get_last( q->list );
}
void enqueue(
    queue *q,
    void *data )
{
    if ( !q || !q->list )
        return ;

    q->list->insert( q->list, data );
}
void *dequeue(
    queue *q )
{
    if ( !q || !q->list )
        return NULL;

    q->list->del( q->list );
}
int queue_size(
    queue *q )
{
    if ( !q || !q->list)
        return 0;
    return q->list->size;
}
void queue_free(
    queue *q )
{
    if ( !q )
        return ;
    if ( !q->list ) {
        free( q );
        return;
    }

    while ( q->dequeue( q->this ) );

    free( q->list );
    free( q );
}
queue *create_queue()
{
    queue *q = NULL;

    q = ( queue * )malloc( sizeof(queue) );
    q->first = queue_get_first;
    q->last = queue_get_last;
    q->enqueue = enqueue;
    q->dequeue = dequeue;
    q->size = queue_size;
    q->free = queue_free;
    q->list = ( link_list * )malloc( sizeof(link_list) );
    q->list->size = 0;
    q->list->insert = insert_tail;
    q->list->get_first = get_head;
    q->list->get_last = get_tail;
    q->list->del = del_head;
    q->this = q;
}

#undef DEBUG_QUEUE
#ifdef DEBUG_QUEUE
void test_queue()
{
    queue *q = create_queue();
    int data1 = 5;
    int data2 = 6;
    int data3 = 7;
    q->enqueue(q->this, (void *)&data1);
    PRINT("q->last:%d", *(int *)q->last(q->this));
    q->enqueue(q->this, (void *)&data2);
    PRINT("q->last:%d", *(int *)q->last(q->this));
    q->enqueue(q->this, (void *)&data3);
    PRINT("q->last:%d\n", *(int *)q->last(q->this));

    PRINT("q->size:%d\n", q->size(q->this));

    PRINT("q->first:%d", (int)*(int *)(q->first(q->this)));
    PRINT("q->last:%d\n", (int)*(int *)(q->last(q->this)));

    PRINT("q->dequeue:%d", (int)*(int *)(q->dequeue(q->this)));
    PRINT("q->first:%d", (int)*(int *)(q->first(q->this)));
    PRINT("q->size:%d\n", q->size(q->this));

    PRINT("q->dequeue:%d", (int)*(int *)(q->dequeue(q->this)));
    PRINT("q->first:%d", (int)*(int *)(q->first(q->this)));
    PRINT("q->size:%d\n", q->size(q->this));

    PRINT("q->dequeue the last element");
    q->dequeue(q->this);
    PRINT("q->size:%d\n", q->size(q->this));

    q->free( q->this );
}
int main()
{
    test_queue();

    return 0;
}
#endif

/*****************************************************************/

/*****************************栈********************************/

typedef struct stack {
    void *(*first)( struct stack *this );
    void *(*last)( struct stack *this );
    void (*push)( struct stack *this, void *data );
    void *(*pop)( struct stack *this );
    int (*size)( struct stack *this );
    void (*free)( struct stack *this );
    struct link_list *list;
    struct stack *this;
} stack;
void *stack_get_first(
    stack *s )
{
    if ( !s || !s->list )
        return NULL;

    return s->list->get_first( s->list );
}
void *stack_get_last(
    stack *s )
{
    if ( !s || !s->list )
        return NULL;

    return s->list->get_last( s->list );
}
void stack_push(
    stack *s,
    void *data )
{
    if ( !s || !s->list )
        return ;

    s->list->insert( s->list, data );
}
void *stack_pop(
    stack *s )
{
    if ( !s || !s->list )
        return NULL;

    s->list->del( s->list );
}
int stack_size(
    stack *s )
{
    if ( !s || !s->list)
        return 0;
    return s->list->size;
}
void stack_free(
    stack *s )
{
    if ( !s )
        return ;
    if ( !s->list ) {
        free( s );
        return;
    }

    while ( s->pop( s->this ) );

    free( s->list );
    free( s );
}
stack *create_stack()
{
    stack *s = NULL;

    s = ( stack * )malloc( sizeof(stack) );
    s->first = stack_get_first;
    s->last = stack_get_last;
    s->push = stack_push;
    s->pop = stack_pop;
    s->size = stack_size;
    s->free = stack_free;
    s->list = ( link_list * )malloc( sizeof(link_list) );
    s->list->size = 0;
    s->list->insert = insert_tail;
    s->list->get_first = get_tail;
    s->list->get_last = get_head;
    s->list->del = del_tail;
    s->this = s;
}

#define DEBUG_STACK
#ifdef DEBUG_STACK
void test_stack()
{
    stack *s = create_stack();
    int data1 = 5;
    int data2 = 6;
    int data3 = 7;
    s->push(s->this, (void *)&data1);
    PRINT("s->first:%d", *(int *)s->first(s->this));
    s->push(s->this, (void *)&data2);
    PRINT("s->first:%d", *(int *)s->first(s->this));
    s->push(s->this, (void *)&data3);
    PRINT("s->first:%d\n", *(int *)s->first(s->this));

    PRINT("s->size:%d\n", s->size(s->this));

    PRINT("s->last:%d", (int)*(int *)(s->last(s->this)));
    PRINT("s->first:%d\n", (int)*(int *)(s->first(s->this)));

    PRINT("s->pop:%d", (int)*(int *)(s->pop(s->this)));
    PRINT("s->first:%d", (int)*(int *)(s->first(s->this)));
    PRINT("s->size:%d\n", s->size(s->this));

    PRINT("s->pop:%d", (int)*(int *)(s->pop(s->this)));
    PRINT("s->first:%d", (int)*(int *)(s->first(s->this)));
    PRINT("s->size:%d\n", s->size(s->this));

    PRINT("s->pop the first element");
    s->pop(s->this);
    PRINT("s->size:%d\n", s->size(s->this));

    s->free( s->this );
}
int main()
{
    test_stack();

    return 0;
}
#endif
lkness
关注
专栏目录
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 9万+
C/C++学习路线总结与分享
【c++20】CPP-20-STL-Cookbook 学习笔记
突围
03-29 254
c++20
一种通用队列的实现
10-08
个人编写的，简单、通用队列，代码量不超过50行，主要用指针实现，有能用得到的可以参考参考。适合8-32位单片机（地址16-32位）。
【算法导论】链表队列
青峰碧陋室
12-06 2140
链表队列很简单，之前看到过，没有用程序实现。其原理就是遵循FIFO原则,只能从队首取元素，从队尾插入元素，就和排队模型一样。因此只需要队首指针和队尾指针就可以方便的进行队列操作。因为在最近看的图论算法中，经常用到队列，在这里就先用程序实现链表队列。 和单链表一样，为了运算方便，我们也在队头节点前附加一个头结点，且头指针指向头结点。其链表队列的示意图如下： 下面是具体的程序实现： #i
队列、栈与链表
Eureka1024的博客
06-20 9694
一、队列    队列，顾名思义，就像排队一样，我们只能在队首删除，在队尾增加。队列是一种先进先出（FIFO）的数据结构。    参考：队列的解析与C语言实现二、栈      栈，可以理解为一个储物的地方，且只有一个出口，先放进去的东西最后才能拿出来（因为被后面放进去的东西挡住了）。栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出(FILO)的原则存储数据，先进入的...
用双端链表实现通用栈
lotluck的专栏
12-09 902
这篇 还是双端链表基础上实现，这里面只是在套组件，套写过的东西，就需要重新组合一下而已，也许以后在公司也就是这个样子，感觉C语言越来越强大了，还需要好好搞搞C语言，关于栈，不想多BB，感觉说啥概念没意思了，也就是上代码，这是如何实现的   stack.h文件 #ifndef _STACK_H_ #define _STACK_H_ #include "dlist.h" #include "
栈队列链表算法总结
weixin_34179968的博客
03-18 103
1.队列 struct queue{ int head; int tail; int a[1001];}; 2.栈 栈的基本操作： 定义栈：stack<int> S; 入栈（定义栈元素）：S.push(i); 出栈（删除栈元素）：S.pop(); 返回栈顶元素的值：S.top(); 判断栈是否为空：S.empty(); //值为0说明不空 值为1说明栈为空 ...
数据结构与算法之美专栏笔记_数组链表栈篇
qq_48573752的博客
02-02 1327
提要 在具体的算法题解之前，我们先简要的描述一些知识点，这些知识点都是基于数据结构与算法专栏内容的总结，其中也涉及一些评论区的见解，我仅做整理。对于详细的推理不再涉及，仅当做笔记使用。 从一个问题开始 为什么大部分编程语言中，数组要从0开始编号，而不是从1开始？ 从数组存储的内存模型来看，数组的下标实际上指的是内存地址的偏移，假设用a表示数组的首地址，将数组元素的类型所占字节数计为type_size，那么a[k]表示的含义就是存储在内存空间k*typesize+base_addr处的元素，如果从1开始编号.
基于《狂神说Java》Redis--学习笔记
wudidahuanggua的博客
06-19 1675
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!
《B站-青岛大学-王卓老师-数据结构与算法基础》自学心得、笔记（C++语言实现）.zip
最新发布
06-16
资料大全中的其他语言（C、Java、Python）的学习资料，则提供了跨语言视角，帮助理解数据结构和算法的通用性与语言特性之间的关系。 总的来说，无论是对数据结构的深入理解，还是对C++语言的熟练运用，这个课程和...
链表，顺序表，队列，栈的实现
09-19
这里有顺序变，链表，栈，队列的实现的完整程序，程序附加有大量说明，链表中还包含循环链表，双向链表，同时又串，图的程序。
一个通用纯C队列的实现
kxcfzyk的专栏
06-17 4843
队列并不是很复杂的数据结构，但是非常实用，这里实现一个队列是为了
栈、队列和链表
Lurfee的博客
05-30 486
栈，队列，链表，python
C 语言 通用队列
C-Onely的博客
12-20 373
C 语言 队列
数据结构:通用队列
sliver.chen的博客
02-22 327
队列 队列和链表比较类似 不同之处在于队列仅允许从队列头部(front)删除节点 从队列尾部(rear)增加节点 可以将队列看作是栈的反例 队列:先入先出(FIFO) 栈:先入后出(LIFO) 前文已经分析过栈的原理: http://blog.csdn.net/qq_21358401/article/details/7...
Day11——通用队列
Z__XY_的博客
04-10 600
前几天有遇到int类型的队列、char类型的队列还有以对象作为元素的队列，它们之间除了数据类型不同，其它都相同，之前我们都是一个类型对应一个类，今天就写一个通用队列。 老师的思路：Java中万物皆对象，我们只用写一个类型为Object的队列，使用时可以通过强制类型转换，得到我们想要的类型，所以我们可以直接用CircleObjectQueue来创建我们所需要的所有队列。 package day11; import java.util.Arrays; public class BinaryCharTree
栈 通用链表实现
u011730792的专栏
04-15 605
c语言，栈 通过list_head单链表，实现
数据结构6.通用队列
Aemonair's　世界树．
06-18 643
引言 二、队列定义及实现 - 队列定义： - 通用链表接口： - 队列实现： 三、代码功能测试 - 测试代码： - 测试结果： 总结
数据结构（栈/队列/链表）
weixin_47667133的博客
07-20 965
线性数据结构 2. 什么叫做数据结构 数据结构是计算机存储、组织数据的方式。指的是相互之间存在一种或多种特定关系的数据元素的集合。 ​ – 百度百科 可比喻成一个企业的组织结构，组织结构其实就是部门与部门之间的关系结构。 数据结构就是用来描述数据与数据之间的关系 线性和非线性数据结构 线性结构：数据元素之间一对一的关系 非线性结构：数据元素之间一对多的关系 存储方式 顺序存储：Set、Array 散列存储：Map、Object
C++数据结构探索：链表、栈、队列与排序算法
"C++课件涵盖了链表、栈、队列、线性群体以及排序和查找等基础知识，强调了栈中的数据先进后出原则，并提供了相关操作的实现与范例。" C++是一种强大的编程语言，尤其在处理数据结构方面具有很高的灵活性。在本课件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值