[C基础]栈、单向链表和队列的简易C实现

最新推荐文章于 2023-03-28 22:44:09 发布
最新推荐文章于 2023-03-28 22:44:09 发布
阅读量1.3k 收藏
点赞数
分类专栏： C 文章标签： 队列 链表 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xqjcool/article/details/123770105
版权

C语言比较偏底层，很多常用的数据结构需要自己实现，不像高等语言直接就有现成的类库可使用。

1. 栈定义和实现

下面是一个栈的简易实现，适合新人入门参考。可以方便的对任意数据类型进行压栈出栈操作。

#define MAX_STACK_DEPTH 4096

typedef struct _STACK
{
    void *Array[MAX_STACK_DEPTH];
    int  Depth;
    void (*Push)(struct _STACK *,void *);
    void *(*Pop)(struct _STACK *);
}
STACK;

void StackPush(STACK *Stack, void *Element)
{
    if (Stack->Depth < MAX_STACK_DEPTH)
    {
        Stack->Array[Stack->Depth++] = Element;
    }
}

void *StackPop(STACK *Stack)
{
    if (Stack->Depth <= 0)
    {
        return NULL;
    }

    return Stack->Array[--Stack->Depth];
}

注意：

为了简单，我们没有考虑栈溢出情况。如果使用环境可能存在压栈溢出。我们需要改进StackPush函数，增加溢出判断。

int StackPush(STACK *Stack, void *Element)
{
    if (Stack->Depth >= MAX_STACK_DEPTH)
    {
        return -1;
    }

    Stack->Array[Stack->Depth++] = Element;
    return 0;
}

2. 单向链表定义和实现

单向链表在实际使用中非常常见，下面是其定义和实现，包含了用来验证的创建、释放、打印函数。

typedef struct _NODE
{
    struct _NODE *Next;
    int Value;
}
NODE;

void ListPrint(NODE *Head)
{
    while (Head)
    {
        printf("%d ", Head->Value);
        Head = Head->Next;
    }
    printf("\n");
}

void ListFree(NODE *Head)
{
    NODE *tmp = NULL;
    while (Head)
    {
        tmp = Head->Next;
        free(Head);
        Head = tmp;
    }
}

NODE *ListCreate(void)
{
    NODE *head = NULL, *lastNode = NULL, *curNode = NULL;
    int val = 0;

    printf("please input space-separated elements:\n");
    while (scanf("%d", &val) != EOF)
    {
        curNode = (NODE *)malloc(sizeof(NODE));
        if (curNode == NULL)
        {
            return head;    /* malloc failure, return current created list */
        }
        curNode->Value = val;
        curNode->Next = NULL;

        if (head == NULL)
        {
            head = curNode;
        }

        if (lastNode == NULL)
        {
            lastNode = curNode;
        }
        else
        {
            lastNode->Next = curNode;
            lastNode = curNode;
        }
        
        if (getchar() == '\n')
        {
            break;
        }
    }

    return head;
}

栈和链表综合使用示例--单向链表的反转：

通常我们使用多个指针逐步实现链表反转，但是栈天生就具备反转特性，所以使用栈来实现更简洁一些。

NODE *ListReverse(NODE *Head)
{
    NODE *curNode = NULL;
    STACK stack = {.Depth = 0, .Push = StackPush, .Pop = StackPop};

    if (Head == NULL)
    {
        return NULL;
    }

    while (Head)
    {
        stack.Push(&stack, (void *)Head);
        Head = Head->Next;
    }

    Head = (NODE *)stack.Pop(&stack);
    curNode = Head;
    while (stack.Depth > 0)
    {
        curNode->Next = (NODE *)stack.Pop(&stack);
        curNode = curNode->Next;
    }
    curNode->Next = NULL;
    
    return Head;
}

完整示例代码：

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

#define MAX_STACK_DEPTH 4096

typedef struct _STACK
{
    void *Array[MAX_STACK_DEPTH];
    int  Depth;
    void (*Push)(struct _STACK *,void *);
    void *(*Pop)(struct _STACK *);
}
STACK;

void StackPush(STACK *Stack, void *Element)
{
    if (Stack->Depth < MAX_STACK_DEPTH)
    {
        Stack->Array[Stack->Depth++] = Element;
    }
}

void *StackPop(STACK *Stack)
{
    if (Stack->Depth <= 0)
    {
        return NULL;
    }

    return Stack->Array[--Stack->Depth];
}

typedef struct _NODE
{
    struct _NODE *Next;
    int Value;
}
NODE;

void ListPrint(NODE *Head)
{
    while (Head)
    {
        printf("%d ", Head->Value);
        Head = Head->Next;
    }
    printf("\n");
}

void ListFree(NODE *Head)
{
    NODE *tmp = NULL;
    while (Head)
    {
        tmp = Head->Next;
        free(Head);
        Head = tmp;
    }
}

NODE *ListCreate(void)
{
    NODE *head = NULL, *lastNode = NULL, *curNode = NULL;
    int val = 0;

    printf("please input space-separated elements:\n");
    while (scanf("%d", &val) != EOF)
    {
        curNode = (NODE *)malloc(sizeof(NODE));
        if (curNode == NULL)
        {
            return head;    /* malloc failure, return current created list */
        }
        curNode->Value = val;
        curNode->Next = NULL;

        if (head == NULL)
        {
            head = curNode;
        }

        if (lastNode == NULL)
        {
            lastNode = curNode;
        }
        else
        {
            lastNode->Next = curNode;
            lastNode = curNode;
        }
        
        if (getchar() == '\n')
        {
            break;
        }
    }

    return head;
}

NODE *ListReverse(NODE *Head)
{
    NODE *curNode = NULL;
    STACK stack = {.Depth = 0, .Push = StackPush, .Pop = StackPop};

    if (Head == NULL)
    {
        return NULL;
    }

    while (Head)
    {
        stack.Push(&stack, (void *)Head);
        Head = Head->Next;
    }

    Head = (NODE *)stack.Pop(&stack);
    curNode = Head;
    while (stack.Depth > 0)
    {
        curNode->Next = (NODE *)stack.Pop(&stack);
        curNode = curNode->Next;
    }
    curNode->Next = NULL;
    
    return Head;
}

int main(int argc, char *argv[])
{
   NODE *list = NULL;

   list = ListCreate();
   ListPrint(list);
   list = ListReverse(list);
   ListPrint(list);
   ListFree(list);
   return 0;
}

3. 队列定义和实现

下面是一个队列的建议实现，遵循先进先出原则，从队头Pop弹出元素，从队尾Push压入元素。

#define MAX_QUEUE_LENGTH 4096

typedef struct _QUEUE
{
    void *Array[MAX_QUEUE_LENGTH];
    int Length;
    int Head;
    int Tail;
    void (*Push)(struct _QUEUE *, void *);
    void *(*Pop)(struct _QUEUE *);
}
QUEUE;

void QueuePush(QUEUE *Queue, void *Element)
{
    if (Queue->Length >= MAX_QUEUE_LENGTH)
    {
        return;
    }

    Queue->Array[Queue->Tail] = Element;
    if (Queue->Tail < MAX_QUEUE_LENGTH - 1)
    {
        Queue->Tail++;
    }
    else
    {
        Queue->Tail = 0;
    }
    Queue->Length++;
}

void *QueuePop(QUEUE *Queue)
{
    void *ele = NULL;

    if (Queue->Length <= 0)
    {
        return NULL;
    }

    ele = Queue->Array[Queue->Head];
    if (Queue->Head < MAX_QUEUE_LENGTH - 1)
    {
        Queue->Head++;
    }
    else
    {
        Queue->Head = 0;
    }
    Queue->Length--;

    return ele;
}

/*
 * Common Usage:
 * 1. QUEUE queue = {.Length = 0, .Head = 0, .Tail = 0, .Push = QueuePush, .Pop = QueuePop};
 *    queue.Push(&queue, (void *)ele);
 *    ele = (eleType)queue.Pop(&queue);
 * 2. QUEUE *queue = (QUEUE *)malloc(sizeof(QUEUE));
 *    queue->Length = queue->Head = queue->Tail = 0;
 *    queue->Push = QueuePush;
 *    queue->Pop = QueuePop;
 *    queue->Push(queue, (void *)ele);
 *    ele = (eleType)queue->Pop(queue);
 */

注意：

为了简单，我们没有考虑队列溢出情况。如果使用环境可能存在队列溢出。我们需要改进QueuePush函数，增加溢出判断。

int QueuePush(QUEUE *Queue, void *Element)
{
    if (Queue->Length >= MAX_QUEUE_LENGTH)
    {
        return -1;
    }

    Queue->Array[Queue->Tail] = Element;
    if (Queue->Tail < MAX_QUEUE_LENGTH - 1)
    {
        Queue->Tail++;
    }
    else
    {
        Queue->Tail = 0;
    }
    Queue->Length++;
    return 0;
}

队列和栈的示例--两个队列实现栈：

typedef struct _QUEUE_STACK
{
    QUEUE Queue1;
    QUEUE Queue2;
}
QUEUE_STACK;

int QueueStackDepth(QUEUE_STACK *Stack)
{
    if (Stack->Queue1.Length == 0 && Stack->Queue2.Length == 0)
    {
        return 0;
    }
    else if (Stack->Queue1.Length == 0)
    {
        return Stack->Queue2.Length;
    }
    else
    {
        return Stack->Queue1.Length;
    }
}

void QueueStackPush(QUEUE_STACK *Stack, void *Element)
{
    if (Stack->Queue1.Length > 0)
    {
        Stack->Queue1.Push(&Stack->Queue1, Element);
    }
    else
    {
        Stack->Queue2.Push(&Stack->Queue2, Element);
    }
}

void *QueueStackPop(QUEUE_STACK *Stack)
{
    QUEUE *popQueue = NULL, *pushQueue = NULL;
    void *ele = NULL;
    
    if (Stack->Queue1.Length == 0 && Stack->Queue2.Length == 0)
    {
        return NULL;
    }
    else if (Stack->Queue1.Length == 0)
    {
        pushQueue = &Stack->Queue1;
        popQueue = &Stack->Queue2;
    }
    else
    {
        pushQueue = &Stack->Queue2;
        popQueue = &Stack->Queue1;  
    }
    
    while (popQueue->Length > 1)
    {
        ele = popQueue->Pop(popQueue);
        pushQueue->Push(pushQueue, ele)
    }

    return popQueue->Pop(popQueue);
}

完整示例代码如下，直接gcc编译执行：

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

#define MAX_QUEUE_LENGTH 4096

typedef struct _QUEUE
{
    void *Array[MAX_QUEUE_LENGTH];
    int Length;
    int Head;
    int Tail;
    void (*Push)(struct _QUEUE *, void *);
    void *(*Pop)(struct _QUEUE *);
}
QUEUE;

void QueuePush(QUEUE *Queue, void *Element)
{
    if (Queue->Length >= MAX_QUEUE_LENGTH)
    {
        return;
    }

    Queue->Array[Queue->Tail] = Element;
    if (Queue->Tail < MAX_QUEUE_LENGTH - 1)
    {
        Queue->Tail++;
    }
    else
    {
        Queue->Tail = 0;
    }
    Queue->Length++;
}

void *QueuePop(QUEUE *Queue)
{
    void *ele = NULL;

    if (Queue->Length <= 0)
    {
        return NULL;
    }

    ele = Queue->Array[Queue->Head];
    if (Queue->Head < MAX_QUEUE_LENGTH - 1)
    {
        Queue->Head++;
    }
    else
    {
        Queue->Head = 0;
    }
    Queue->Length--;

    return ele;
}

typedef struct _QUEUE_STACK
{
    QUEUE Queue1;
    QUEUE Queue2;
}
QUEUE_STACK;

int QueueStackDepth(QUEUE_STACK *Stack)
{
    if (Stack->Queue1.Length == 0 && Stack->Queue2.Length == 0)
    {
        return 0;
    }
    else if (Stack->Queue1.Length == 0)
    {
        return Stack->Queue2.Length;
    }
    else
    {
        return Stack->Queue1.Length;
    }
}

void QueueStackPush(QUEUE_STACK *Stack, void *Element)
{
    if (Stack->Queue1.Length > 0)
    {
        Stack->Queue1.Push(&Stack->Queue1, Element);
    }
    else
    {
        Stack->Queue2.Push(&Stack->Queue2, Element);
    }
}

void *QueueStackPop(QUEUE_STACK *Stack)
{
    QUEUE *popQueue = NULL, *pushQueue = NULL;
    void *ele = NULL;

    if (Stack->Queue1.Length == 0 && Stack->Queue2.Length == 0)
    {
        return NULL;
    }
    else if (Stack->Queue1.Length == 0)
    {
        pushQueue = &Stack->Queue1;
        popQueue = &Stack->Queue2;
    }
    else
    {
        pushQueue = &Stack->Queue2;
        popQueue = &Stack->Queue1;
    }

    while (popQueue->Length > 1)
    {
        ele = popQueue->Pop(popQueue);
        pushQueue->Push(pushQueue, ele);
    }

    return popQueue->Pop(popQueue);
}

int main(int argc, char *argv[])
{
    QUEUE_STACK stack;
    int val = 0;

    stack.Queue1.Push = QueuePush;
    stack.Queue1.Pop = QueuePop;
    stack.Queue1.Length  = stack.Queue1.Head = stack.Queue1.Tail = 0;

    stack.Queue2.Push = QueuePush;
    stack.Queue2.Pop = QueuePop;
    stack.Queue2.Length  = stack.Queue2.Head = stack.Queue2.Tail = 0;

    printf("please input space-separated elements:\n")
    while (scanf("%d", &val) != EOF)
    {
        QueueStackPush(&stack, (void *)val);

        if (getchar() == '\n')
        {
            break;
        }
    }

    while (QueueStackDepth(&stack) > 0)
    {
        val = (int)QueueStackPop(&stack);
        printf("%d ", val);
    }
    printf("\n");

    return 0;
}

浮沉飘摇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
用双向链表做的DOS版的学生信息管理程序
06-01
在IT领域，数据结构是计算机科学的基础之一，而链表...此外，项目中的代码实现也能帮助我们学习C语言或其他低级语言的基本语法和编程技巧。总之，这是一个非常实用的学习资源，对于提升数据结构和算法能力大有裨益。
若干源程序资料12.rar
06-11
2012-06-11 21:35 50,176 关于c语言和汇编语言相互嵌套调用的学习总结.doc 2012-06-11 21:11 190,993 典型算法包.rar 2012-06-11 21:16 264,555 内存管理和设备调试中文.pdf 2012-06-11 21:30 267,989 冈萨雷斯数字...
队列的讲解和实现（图解+代码/C语言+循环队列OJ）
qq_62306969的博客
01-13 718
今天为大家分享的是队列的实现，本文主要介绍单向链表来模拟实现队列，最后给出力扣上一道循队列的OJ实现。
C语言实现栈和队列(动态)
最新发布
2301_76269963的博客
03-28 1659
C语言实现栈和队列(动态)
数据结构单向队列c实现（全部函数功能）
四年rain的博客
10-24 241
单向队列 额~~~，相信各位都是巨巨这点内容就不用我介绍啦。 今天十月二十四，程序员节快乐。 （其实写这篇文章也就是为了刷一个徽章而已，Orz,太卑微啦） 队列代码实现： #include<stdlib.h> #include<iostream> #include<stdio.h> #define True 1 #define False 0 #define O...
C语言实现单链队列的基本操作（五）
helloworldpeople的博客
05-21 2330
C语言实现单链队列的基本操作 前面实现了队列的顺序结构，这一篇我们来实现队列的链式结构。 首先说明要使用到的结构体，第一个结构体，struct qnode，它包含两个成员，一个是数据变量data，另外一个是指向下一个节点的指针*next。第二个结构体queue包含的成员是队列的头指针和尾指针，他们都是指向struct qnode的结构体指针。 下面说明需要编写的三个函数：初始化函数Sq_In
C语言实现队列(链表实现)
热门推荐
y6df7的博客
07-13 1万+
队列 (Queue) :也是运算受限的线性表。是一种先进先出 (First In First Out ,简称 FIFO) 的线性表。只允许在表的一端进行插入,而在另一端进行删除。  队首 (front) :允许进行删除的一端称为队首。    队尾 (rear) :允许进行插入的一端称为队尾。   代码： #include &lt;stdio.h&gt; #include &lt;std...
C#程序开发范例宝典（第2版）.part02
11-12
实例234 实现注销、关闭和重启计算机 326 7.2 获得磁盘属性 328 实例235 获得硬盘序列号 328 实例236 获取映射驱动器路径 330 实例237 判断驱动器类型 331 实例238 获取所有逻辑分区 332 7.3 磁盘相关设置 333...
C#程序开发范例宝典（第2版）.part13
11-12
实例234 实现注销、关闭和重启计算机 326 7.2 获得磁盘属性 328 实例235 获得硬盘序列号 328 实例236 获取映射驱动器路径 330 实例237 判断驱动器类型 331 实例238 获取所有逻辑分区 332 7.3 磁盘相关设置 333...
数据结构中的算法都需要实现吗？
迂者-贺利坚的专栏
10-09 5105
【问】　　老师你好，学习数据机构，是不是书上的每一个算法都用程序设计语言在计算机实现？还是只理解算法就可以？【答】　　每一个算法都用程序设计语言在计算机实现？不必绝对这样做，你的时间需要有效利用，实现仅在于增加体验，增加思考以及注意到细节的机会，而不是强制的“任务”。再者，对于程序设计语言本身有待提高的同学而言，这也是熟悉语言的又一个机会。　　只理解算法就可以？理解是一定的，还不够。除了上述必要的
102. 进程间通信 - 消息队列实现单向通信
我思故我在！
01-20 328
管道里面的队列：顺序队列 消息队列：链式队列 本次实现无亲缘关系间进程通信 ftok基于同一个文件，创建唯一的key。基于唯一的key实现两个进程通过内核空间同一个消息队列进程通信 运行代码，发现write.c写入的内容，可以实时被读程序read.c读出 消息队列有两个特点： 1. 读完后就自动删除，相对于出队列 2. 读的时候可以设置为阻塞方式 ...
C语言-数据结构-用单链表实现队列
linkang007的博客
05-27 514
用顺序表实现栈
数据结构：（c实现）手把手教你实现栈和队列（内附详细代码）
qq_51004011的博客
05-22 1087
一：栈 （1）栈的基本概念（物理图解） 在标准规定里，栈是一种特殊的线性表，有栈底和栈顶两端，规定它只能从栈顶出入数据，所以这也是栈的一个基本原则：先入栈的后出栈（后入栈先出栈）。我们在实现一个栈时，通常使用顺序表来实现，以顺序表的表尾来做栈顶。 例如上面的一个栈，栈底的位置一直不改变，从栈顶进一个数据（指向栈顶的指针加一），然后又从栈顶出一个数据（指向栈顶的指针减一）。 （2）栈的基本结构以及初始化 typedef int Stack_data_type; #define M.
连续子数组的最大和
红眼僵尸将臣的博客
09-07 206
题目描述 输入一个整型数组，数组里有正数也有负数，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。 输入描述 输入第一行一个整数序列的序列长度，如：8 输入第二行为整数序列，数字用空格分隔，如：1 -2 3 10 -4 7 2 -5 输出描述 上述最大子数组为{3，1，-4，7，2}，因此输出为18 分析 方法1：枚举所有子数组并求和
C语言实现栈和队列【数据结构/初阶】
Man9o
04-22 2504
C语言实现栈和队列

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

浮沉飘摇

码字不易，打赏随意。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值