基于双链表的队列和栈操作的实现

双向链表实现栈(Java) 2021.12.25 思路: 1.创建一个节点,节点包含编号,next和pre; 2.根据创建的节点创建双向链表 注意:写遍历栈函数时要创建临时节点来遍历,不然就不是遍历栈,而是出栈了,容易造成空指针异常。 //用双向链表创建栈 class LinkedListStack{ //创建头节点 private Node head = new Node(-1); //创建top节点指向最后一个节点 private Node top ... 阅读详情

基于双链表的队列和栈操作的实现


1. 应用需求

1.1 背景

  • 以往队列和栈的实现一般都限制了数据类型和长度,无法做到通用性,因此本文主要考虑通用性实现一套接口解决这个问题。

1.2 前提

  • 动态分配函数,malloc和free。

1.3 功能

  • 支持FIFO/LIFO的常规操作。
  • 不限制每次入队/入栈的数据类型和长度。
  • 采用面向对象的编程思维,便于移植,理论上移植后不需要进行修改源代码

2. 功能实现

2.1 源文件实现

  • Buff.h
#ifndef __BUFF_H__
#define __BUFF_H__

typedef void*   BuffHandle_t;
typedef void *(*mallocCb)(unsigned long size);
typedef void (*freeCb)(void *ptr);
typedef void (*printCb)(const char *format, ...);

BuffHandle_t BuffCreat(unsigned long maxNums, mallocCb mallocFun, freeCb freeFun, printCb printFun);
int BuffDelete(BuffHandle_t handle);

unsigned char BuffIsEmpty(BuffHandle_t handle);
unsigned char BuffIsFull(BuffHandle_t handle);

unsigned int BuffGetNums(BuffHandle_t handle);
unsigned int BuffGetFreeNums(BuffHandle_t handle);

int BuffPushTail(BuffHandle_t handle, void *data, unsigned long dataSize);
int BuffPopTail(BuffHandle_t handle, void *data, unsigned long dataSize);
int BuffPushHead(BuffHandle_t handle, void *data, unsigned long dataSize);
int BuffPopHead(BuffHandle_t handle, void *data, unsigned long dataSize);

int BuffRead(BuffHandle_t handle, void *data, unsigned long dataSize, unsigned long cnt);
void BuffPrint(BuffHandle_t handle);

#endif
  • Buff.c
#include "string.h"
#include "stdio.h"
#include "stdlib.h"

#include "Buff.h"

#ifdef __BUFF_H__

//buff的存储内容对外不可见
typedef struct _BuffNode
{
    unsigned long dataSize;         //数据大小
    void *data;                     //指向数据内容
    struct _BuffNode *prev;         //指向上一个数据地址
    struct _BuffNode *next;         //指向下一个数据地址
} BuffNode_t;

//buff的头信息
typedef struct
{
    unsigned long curNums;
    unsigned long maxNums;
    BuffNode_t *addr;
    mallocCb mallocFun;
    freeCb freeFun;
    printCb printFun;
} BuffHead_t;

//-----------------------------------------------------------------------------
// 名称:BuffCreatNode
// 功能:创建一个动态的节点数据
// 参数:
// 返回:
// 说明:
//-----------------------------------------------------------------------------
static BuffNode_t* BuffCreatNode(BuffHandle_t handle, void *data, unsigned long dataSize)
{
    BuffHead_t *head = (BuffHead_t *)handle;
    void *buff = NULL;
    BuffNode_t *add = NULL;

    //参数检查
    if (handle == NULL || data == NULL || dataSize <= 0)
    {
        return NULL;
    }

    //创建内容缓存
    buff = head->mallocFun(dataSize);
    if (buff == NULL)
    {
        return NULL;
    }

    //非空队列中增加一个节点
    add = (BuffNode_t *)head->mallocFun(sizeof(BuffNode_t));
    if (add == NULL)
    {
        head->freeFun(buff);
        return NULL;
    }

    memcpy(buff, data, dataSize);
    add->dataSize = dataSize;
    add->data = buff;
    add->next = NULL;
    add->next = NULL;

    return add;
}

//-----------------------------------------------------------------------------
// 名称:BuffCreat
// 功能:创建一个Buff
// 参数:void
// 返回:Buff的句柄
// 说明:仅仅是创建一个句柄
//-----------------------------------------------------------------------------
BuffHandle_t BuffCreat(unsigned long maxNums, mallocCb mallocFun, freeCb freeFun, printCb printFun)
{
    BuffHead_t *handle = NULL;

    if (mallocFun == NULL || freeFun == NULL)
    {
        return NULL;
    }

    //创建一个头节点内存
    handle = (BuffHead_t *)mallocFun(sizeof(BuffHead_t));
    if (handle == NULL)
    {
        return NULL;
    }

    //初始化头信息
    handle->curNums = 0;
    handle->maxNums = maxNums;
    handle->addr = NULL;
    handle->mallocFun = mallocFun;
    handle->freeFun = freeFun;
    handle->printFun = printFun;

    return handle;
}

//-----------------------------------------------------------------------------
// 名称:BuffDelete
// 功能:删除Buff
// 参数:Buff句柄
// 返回:成功返回0,否则返回<0
// 说明:
//-----------------------------------------------------------------------------
int BuffDelete(BuffHandle_t handle)
{
    BuffHead_t *head = (BuffHead_t *)handle;
    BuffNode_t *del = NULL;
    unsigned long i = 0;
    unsigned long buffNums = 0;

    //参数异常
    if (handle == NULL)
    {
        return -1;
    }

    buffNums = head->curNums;

    //删除所有的节点
    for (i = 0; i < buffNums; i++)
    {
        del = head->addr;
        if (del->data != NULL)
        {
            head->freeFun(del->data);
        }
        head->addr = del->next;
        head->freeFun(del);
    }

    //删除头信息
    head->freeFun(head);

    return 0;
}

//-----------------------------------------------------------------------------
// 名称:BuffIsEmpty
// 功能:Buff是否为空
// 参数:Buff句柄
// 返回:空Buff返回1,否则返回0
// 说明:
//-----------------------------------------------------------------------------
unsigned char BuffIsEmpty(BuffHandle_t handle)
{
    BuffHead_t *head = (BuffHead_t *)handle;

    //参数错误认为是空buff
    if (handle == NULL)
    {
        return 1;
    }

    if (head->curNums <= 0)
    {
        return 1;
    }

    return 0;
}

//-----------------------------------------------------------------------------
// 名称:BuffIsFull
// 功能:Buff是否为满
// 参数:Buff句柄
// 返回:满Buff返回1,否则返回0
// 说明:
//-----------------------------------------------------------------------------
unsigned char BuffIsFull(BuffHandle_t handle)
{
    BuffHead_t *head = (BuffHead_t *)handle;

    //参数错误认为是空buff
    if (handle == NULL)
    {
        return 0;
    }

    if (head->curNums < head->maxNums)
    {
        return 0;
    }

    return 1;
}

//-----------------------------------------------------------------------------
// 名称:BuffGetNums
// 功能:获取有效Buff数据条数
// 参数:句柄
// 返回:返回数据条数,失败返回0
// 说明:
//-----------------------------------------------------------------------------
unsigned int BuffGetNums(BuffHandle_t handle)
{
    BuffHead_t *head = (BuffHead_t *)handle;

    if (handle == NULL)
    {
        return 0;
    }

    return head->curNums;
}

//-----------------------------------------------------------------------------
// 名称:BuffGetFreeNums
// 功能:获取剩余可用有效数据条数
// 参数:队列句柄
// 返回:返回剩余数据条数,失败返回0
// 说明:
//-----------------------------------------------------------------------------
unsigned int BuffGetFreeNums(BuffHandle_t handle)
{
    BuffHead_t *head = (BuffHead_t *)handle;

    if (handle == NULL)
    {
        return 0;
    }

    return (head->maxNums - head->curNums);
}

//-----------------------------------------------------------------------------
// 名称:BuffPushTail
// 功能:往句柄中尾部添加一条数据
// 参数:handle,句柄
//       data,写入的数据地址
//       dataSize,数据字节数
// 返回:成功返回写入的字节数,否则返回<0
// 说明:
//-----------------------------------------------------------------------------
int BuffPushTail(BuffHandle_t handle, void *data, unsigned long dataSize)
{
    BuffHead_t *head = (BuffHead_t *)handle;
    BuffNode_t *add = NULL;

    //参数检查
    if (handle == NULL || data == NULL || dataSize <= 0)
    {
        return -1;
    }

    //超过最大限制
    if (head->curNums >= head->maxNums)
    {
        BuffPopHead(handle, data, dataSize);
        return -1;
    }

    //创建一个节点
    add = BuffCreatNode(handle, data, dataSize);
    if (add == NULL)
    {
        return -1;
    }

    //空
    if (head->addr == NULL)
    {
        add->next = add;
        add->prev = add;
        head->addr = add;
    }
    //尾插
    else
    {
        add->next = head->addr;
        add->prev = head->addr->prev;
        head->addr->prev->next = add;
        head->addr->prev = add;
    }

    head->curNums++;

    return dataSize;
}

//-----------------------------------------------------------------------------
// 名称:BuffPopTail
// 功能:在BUFF尾部弹出数据
// 参数:handle,Buff句柄
//       data,接收的数据地址
//       dataSize,接收区缓存大小
// 返回:成功返回弹出的字节数,否则返回<0
// 说明:
//-----------------------------------------------------------------------------
int BuffPopTail(BuffHandle_t handle, void *data, unsigned long dataSize)
{
    BuffHead_t *head = (BuffHead_t *)handle;
    BuffNode_t *del = NULL;

    //参数检查
    if (handle == NULL)
    {
        return -1;
    }

    //没有数据
    if (head->curNums <= 0)
    {
        return -1;
    }

    del = head->addr->prev;
    if (del->data != NULL)
    {
        if (data != NULL && dataSize > 0)
        {
            if (dataSize >= del->dataSize)
            {
                dataSize = del->dataSize;
            }
            memcpy(data, del->data, dataSize);
        }
        else
        {
            dataSize = 0;
        }
        head->freeFun(del->data);
    }
    else
    {
        dataSize = 0;
    }

    //有多个节点
    if (head->curNums > 1)
    {
        head->addr->prev = del->prev;
        head->addr->prev->next = head->addr;
    }
    else
    {
        head->addr = NULL;
    }
    head->freeFun(del);
    head->curNums--;

    return dataSize;
}

//-----------------------------------------------------------------------------
// 名称:BuffPushHead
// 功能:往句柄中头部添加一条数据
// 参数:handle,句柄
//       data,写入的数据地址
//       dataSize,数据字节数
// 返回:成功返回写入的字节数,否则返回<0
// 说明:
//-----------------------------------------------------------------------------
int BuffPushHead(BuffHandle_t handle, void *data, unsigned long dataSize)
{
    BuffHead_t *head = (BuffHead_t *)handle;
    BuffNode_t *add = NULL;

    //参数检查
    if (handle == NULL || data == NULL || dataSize <= 0)
    {
        return -1;
    }

    //超过最大限制
    if (head->curNums >= head->maxNums)
    {
        return -1;
    }

    //创建一个节点
    add = BuffCreatNode(handle, data, dataSize);
    if (add == NULL)
    {
        return -1;
    }

    //没有节点
    if (head->addr == NULL)
    {
        add->prev = add;
        add->next = add;
        head->addr = add;
    }
    else
    {
        //头插
        add->next = head->addr;
        add->prev = head->addr->prev;
        head->addr->prev->next = add;
        head->addr->prev = add;
        head->addr = add;
    }

    head->curNums++;

    return dataSize;
}

//-----------------------------------------------------------------------------
// 名称:BuffPopHead
// 功能:在BUFF头部弹出数据
// 参数:handle,Buff句柄
//       data,接收的数据地址
//       dataSize,接收区缓存大小
// 返回:成功返回弹出的字节数,否则返回<0
// 说明:
//-----------------------------------------------------------------------------
int BuffPopHead(BuffHandle_t handle, void *data, unsigned long dataSize)
{
    BuffHead_t *head = (BuffHead_t *)handle;
    BuffNode_t *del = NULL;

    //参数检查
    if (handle == NULL)
    {
        return -1;
    }

    //没有数据
    if (head->curNums <= 0)
    {
        return -1;
    }

    del = head->addr;
    if (del->data != NULL)
    {
        if (data != NULL && dataSize > 0)
        {
            if (dataSize >= del->dataSize)
            {
                dataSize = del->dataSize;
            }
            memcpy(data, del->data, dataSize);
        }
        else
        {
            dataSize = 0;
        }
        head->freeFun(del->data);
    }
    else
    {
        dataSize = 0;
    }

    //有多个节点
    if (head->curNums > 1)
    {
        head->addr = del->next;
        head->addr->prev = del->prev;
        head->addr->prev->next = head->addr;
    }
    else
    {
        head->addr = NULL;
    }

    head->freeFun(del);
    head->curNums--;

    return dataSize;
}

//-----------------------------------------------------------------------------
// 名称:BuffRead
// 功能:在BUFF中读取数据
// 参数:handle,Buff句柄
//       data,接收的数据地址
//       dataSize,接收区缓存大小
//       cnt,读取第几条数据,下标从0开始
// 返回:成功返回弹出的字节数,否则返回<0
// 说明:
//-----------------------------------------------------------------------------
int BuffRead(BuffHandle_t handle, void *data, unsigned long dataSize, unsigned long cnt)
{
    BuffHead_t *head = (BuffHead_t *)handle;
    BuffNode_t *cur = NULL;
    unsigned long i = 0;

    //检查参数
    if (handle == NULL)
    {
        return -1;
    }

    //查看是否符合范围
    if (cnt >= head->curNums)
    {
        return -1;
    }

    cur = head->addr;
    if (cnt < head->curNums - cnt)
    {
        for (i = 0; i < cnt; i++)
        {
            cur = cur->next;
        }
    }
    else
    {
        for (i = 0; i < head->curNums - cnt; i++)
        {
            cur = cur->prev;
        }
    }

    if (cur->data != NULL)
    {
        if (data != NULL && dataSize > 0)
        {
            if (dataSize >= cur->dataSize)
            {
                dataSize = cur->dataSize;
            }
            memcpy(data, cur->data, dataSize);
        }
        else
        {
            dataSize = 0;
        }
    }
    else
    {
        dataSize = 0;
    }

    return dataSize;
}

//-----------------------------------------------------------------------------
// 名称:BuffPrint
// 功能:打印Buff数据
// 参数:handle,Buff句柄
//       printFun,打印接口回调
// 返回:
// 说明:
//-----------------------------------------------------------------------------
void BuffPrint(BuffHandle_t handle)
{
    BuffHead_t *head = (BuffHead_t *)handle;
    BuffNode_t *cur = NULL;
    unsigned long i = 0;

    //参数检查
    if (handle == NULL)
    {
        return;
    }

    if (head->curNums <= 0 || head->printFun == NULL)
    {
        return;
    }

    cur = head->addr;
    for (i = 0; i < head->curNums; i++)
    {
        head->printFun("BuffNode[%d]: prev = 0x%08X, addr = 0x%08X, next = 0x%08X\r\n", i, cur->prev, cur, cur->next);
        cur = cur->next;
    }

    return;
}
#endif

2.2 句柄的定义

  • 作为返回用户操作的地址,空类型表示已对使用者屏蔽内部实现,不需要关注具体实现。
typedef void*   BuffHandle_t;

2.3 外部依赖

  • 创建句柄时需要传入malloc和free用于动态创建才可正常返回可用的句柄。
  • printf非必要传参,不需要调试则传入NULL即可。
typedef void *(*mallocCb)(unsigned long size);
typedef void (*freeCb)(void *ptr);
typedef void (*printCb)(const char *format, ...);

2.4 功能说明

  • BuffCreat:创建一个支持队列/栈链,maxNums表示最大支持的链长,返回一个句柄
  • BuffDelete:删除创建的句柄
  • BuffIsEmpty/BuffIsFull:返回空或满,满状态由maxNums决定了个数
  • BuffGetNums/BuffGetFreeNums:返回当前有效链个数/剩余可用链个数
  • BuffPushHead/BuffPushTail:在头/尾增加数据,不限制数据类型,将数据大小传入即可,正常返回已增加的字节大小
  • BuffPopHead/BuffPopTail:在头/尾移除数据,参数为接收的缓存和缓存大小,返回实际接收的长度
  • BuffRead:cnt为查询的第几包数据,从0开始
  • BuffPrint:打印当前链表的链式情况
BuffHandle_t BuffCreat(unsigned long maxNums, mallocCb mallocFun, freeCb freeFun, printCb printFun);
int BuffDelete(BuffHandle_t handle);

unsigned char BuffIsEmpty(BuffHandle_t handle);
unsigned char BuffIsFull(BuffHandle_t handle);

unsigned int BuffGetNums(BuffHandle_t handle);
unsigned int BuffGetFreeNums(BuffHandle_t handle);

int BuffPushTail(BuffHandle_t handle, void *data, unsigned long dataSize);
int BuffPopTail(BuffHandle_t handle, void *data, unsigned long dataSize);
int BuffPushHead(BuffHandle_t handle, void *data, unsigned long dataSize);
int BuffPopHead(BuffHandle_t handle, void *data, unsigned long dataSize);

int BuffRead(BuffHandle_t handle, void *data, unsigned long dataSize, unsigned long cnt);
void BuffPrint(BuffHandle_t handle);

3. 功能测试

3.1 测试函数

int main(void)
{
    unsigned char step = 0;
    BuffHandle_t handle = NULL;
    int dataSize = 0;
    int wrData = 0;
    int rdData = 0;
    int i = 0;

    while (1)
    {
        switch (step)
        {
        case 0:
            if (handle == NULL)
            {
                handle = BuffCreat(5, malloc, free, printf);
            }
            printf("BuffCreat handle = 0x%08X\r\n", handle);
            step++;
            break;
        case 1:
            dataSize = BuffPushHead(handle, &wrData, sizeof(wrData));
            printf("BuffPushHead:%d, size = %d\r\n", wrData++, dataSize);
            if (BuffIsFull(handle))
            {
                for (i = 0; i < BuffGetNums(handle); i++)
                {
                    dataSize = BuffRead(handle, &rdData, sizeof(rdData), i);
                    printf("BuffRead[%d]:%d, size = %d\r\n", i, rdData, dataSize);
                }
                BuffPrint(handle);
                step++;
            }
            break;
        case 2:
            dataSize = BuffPopHead(handle, &rdData, sizeof(rdData));
            printf("BuffPopHead:%d, size = %d\r\n", rdData, dataSize);
            if (BuffIsEmpty(handle))
            {
                step++;
            }
            break;
        case 3:
            dataSize = BuffPushTail(handle, &wrData, sizeof(wrData));
            printf("BuffPushTail:%d, size = %d\r\n", wrData++, dataSize);
            if (BuffIsFull(handle))
            {
                for (i = 0; i < BuffGetNums(handle); i++)
                {
                    dataSize = BuffRead(handle, &rdData, sizeof(rdData), i);
                    printf("BuffRead[%d]:%d, size = %d\r\n", i, rdData, dataSize);
                }
                BuffPrint(handle);
                step++;
            }
            break;
        case 4:
            dataSize = BuffPopTail(handle, &rdData, sizeof(rdData));
            printf("BuffPopTail:%d, size = %d\r\n", rdData, dataSize);
            if (BuffIsEmpty(handle))
            {
                step++;
            }
            break;
        case 5:
            if (wrData % 2)
            {
                dataSize = BuffPushHead(handle, &wrData, sizeof(wrData));
                printf("BuffPushHead:%d, size = %d\r\n", wrData++, dataSize);
            }
            else
            {
                dataSize = BuffPushTail(handle, &wrData, sizeof(wrData));
                printf("BuffPushTail:%d, size = %d\r\n", wrData++, dataSize);
            }
            if (BuffIsFull(handle))
            {
                for (i = 0; i < BuffGetNums(handle); i++)
                {
                    dataSize = BuffRead(handle, &rdData, sizeof(rdData), i);
                    printf("BuffRead[%d]:%d, size = %d\r\n", i, rdData, dataSize);
                }
                BuffPrint(handle);
                step++;
            }
            break;
        case 6:
            if (wrData % 2)
            {
                dataSize = BuffPopTail(handle, &rdData, sizeof(rdData));
                printf("BuffPopTail:%d, size = %d\r\n", rdData, dataSize);
            }
            else
            {
                dataSize = BuffPopHead(handle, &rdData, sizeof(rdData));
                printf("BuffPopHead:%d, size = %d\r\n", rdData, dataSize);
            }
            if (BuffIsEmpty(handle))
            {
                step++;
            }
        default:
            printf("BuffDelete:0x%08X, ret = %d\r\n", handle, BuffDelete(handle));
            handle = NULL;
            break;
        }

        if (handle == NULL)
        {
            break;
        }
    }

    return 0;
}

3.2 测试结果

BuffCreat handle = 0x006E13D0

BuffPushHead:0, size = 4

BuffPushHead:1, size = 4

BuffPushHead:2, size = 4

BuffPushHead:3, size = 4

BuffPushHead:4, size = 4

BuffRead[0]:4, size = 4

BuffRead[1]:3, size = 4

BuffRead[2]:2, size = 4

BuffRead[3]:1, size = 4

BuffRead[4]:0, size = 4

BuffNode[0]: prev = 0x006E6AB0, addr = 0x006E6BF0, next = 0x006E6BA0

BuffNode[1]: prev = 0x006E6BF0, addr = 0x006E6BA0, next = 0x006E6B50

BuffNode[2]: prev = 0x006E6BA0, addr = 0x006E6B50, next = 0x006E6B00

BuffNode[3]: prev = 0x006E6B50, addr = 0x006E6B00, next = 0x006E6AB0

BuffNode[4]: prev = 0x006E6B00, addr = 0x006E6AB0, next = 0x006E6BF0

BuffPopHead:4, size = 4

BuffPopHead:3, size = 4

BuffPopHead:2, size = 4

BuffPopHead:1, size = 4

BuffPopHead:0, size = 4

BuffPushTail:5, size = 4

BuffPushTail:6, size = 4

BuffPushTail:7, size = 4

BuffPushTail:8, size = 4

BuffPushTail:9, size = 4

BuffRead[0]:5, size = 4

BuffRead[1]:6, size = 4

BuffRead[2]:7, size = 4

BuffRead[3]:8, size = 4

BuffRead[4]:9, size = 4

BuffNode[0]: prev = 0x006E6BF0, addr = 0x006E6AB0, next = 0x006E6B00

BuffNode[1]: prev = 0x006E6AB0, addr = 0x006E6B00, next = 0x006E6B50

BuffNode[2]: prev = 0x006E6B00, addr = 0x006E6B50, next = 0x006E6BA0

BuffNode[3]: prev = 0x006E6B50, addr = 0x006E6BA0, next = 0x006E6BF0

BuffNode[4]: prev = 0x006E6BA0, addr = 0x006E6BF0, next = 0x006E6AB0

BuffPopTail:9, size = 4

BuffPopTail:8, size = 4

BuffPopTail:7, size = 4

BuffPopTail:6, size = 4

BuffPopTail:5, size = 4

BuffPushTail:10, size = 4

BuffPushHead:11, size = 4

BuffPushTail:12, size = 4

BuffPushHead:13, size = 4

BuffPushTail:14, size = 4

BuffRead[0]:13, size = 4

BuffRead[1]:11, size = 4

BuffRead[2]:10, size = 4

BuffRead[3]:12, size = 4

BuffRead[4]:14, size = 4

BuffNode[0]: prev = 0x006E6BF0, addr = 0x006E6BA0, next = 0x006E6B00

BuffNode[1]: prev = 0x006E6BA0, addr = 0x006E6B00, next = 0x006E6AB0

BuffNode[2]: prev = 0x006E6B00, addr = 0x006E6AB0, next = 0x006E6B50

BuffNode[3]: prev = 0x006E6AB0, addr = 0x006E6B50, next = 0x006E6BF0

BuffNode[4]: prev = 0x006E6B50, addr = 0x006E6BF0, next = 0x006E6BA0

BuffPopTail:14, size = 4

BuffDelete:0x006E13D0, ret = 0

2023-03-15 李不清的烦恼,总结篇。

Java单链表和双链表的反转及实现队列、栈和双端队列 算法与数据结构基础:介绍单链表和双链表结构、链表反转及实现队列、栈和双端队列 阅读详情

相关推荐

实现带有双向链表的堆栈算法

堆栈(Stack)是一种常见的数据结构,遵循后进先出(Last-In-First-Out,LIFO)的原则。双向链表(Doubly Linked List)是一种链表,每个节点都包含指向前一个节点和后一个节点的指针。在本文中,我们将结合这两种数据结构,实现一个带有双向链表的堆栈算法。接下来,我们定义一个堆栈类,该类包含一些基本的堆栈操作,如入栈(push)、出栈(pop)、判断堆栈是否为空(is_empty)等。首先,我们需要定义一个节点类,表示双向链表的节点。)将新的节点插入到链表的头部,出栈操作(

code_welike的博客 127

双向链表实现栈

双向链表来实现栈

m0_56398287的博客 1713

从脑电到脑机接口:EEG/ERP特征如何驱动你的下一个智能硬件项目(Arduino/树莓派实战)

本文详细介绍了如何利用EEG/ERP特征提取技术驱动智能硬件项目,涵盖从脑电信号采集到脑机接口实现的完整流程。通过Arduino和树莓派实战,展示了P300、N400等事件相关电位的应用,帮助开发者将学术理论转化为可编程的交互指令,适用于智能家居、医疗辅助等领域。

weixin_29279047的博客 384

双链表与栈

双链表与栈

qq_64743318的博客 689

DIY T12烙铁头驱动难题:用几个电容二极管,搞定NMOS上管驱动(附Multisim仿真)

本文详细介绍了如何利用电荷泵电路解决DIY T12烙铁头驱动中的NMOS上管驱动难题。通过巧妙组合电容和二极管,构建低成本高效的升压电路,实现栅极高压驱动需求。文章包含具体电路设计、元件选型建议、实际搭建注意事项以及Multisim仿真验证,为电子爱好者提供了一套完整的解决方案。

weixin_33640562的博客 337

FPGA新手必看:XC7Z020最小系统搭建全攻略(附原理图解析)

本文为FPGA新手提供了XC7Z020最小系统搭建的完整实战指南。文章详细解析了电源架构、时钟复位、配置调试等关键硬件电路设计,并重点剖析了外围电路与端口引脚的连接要点及常见陷阱,帮助读者从零开始构建稳定可靠的开发平台。

weixin_29189377的博客 360

双链表&栈

双链表的实现,添加、删除、查找节点操作; 栈的实现:入栈、出栈、查找栈顶元素操作; 栈的算法实例:最小栈,逆波兰表达式,括号匹配,栈的压入,弹出序列

Krive~Irving 1365

UG NX与PLC-1500的在环虚拟测试

TIA、PLCSIM、NetToPLCsim、KEPServerEX以及UG NX的在环虚拟测试

lvtlvtlvtlvt的博客 4220

双链表队列和栈的实现与操作

#include using namespace std; // node definition struct que_elem {     que_elem* prev_p;     que_elem* next_p;     int data; }; // queue definition struct que_struct {     que_ele

火娃的专栏 420

Spring Security 珍藏版快速入门

文章目录一、前期配置二、Spring Security 测试三、案例:自定义页面(XML配置用户信息)三、案例:自定义页面(数据库存储用户信息) 一、前期配置 (1)pom.xml <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-web</artifactId> <version>${s

南淮北安的博客 635

Android Camera驱动开发工程师面试指南:技术深度与实战准备

摘要:上海移远通信招聘Android Camera驱动开发工程师,主要负责Camera传感器驱动开发维护、高通/展锐平台底层开发及技术预研。岗位要求1年以上嵌入式开发经验,精通Camera传感器驱动调试,熟悉高通平台Camera架构及Android HAL框架。具备HAL开发、算法集成或车载/支付行业经验者优先。工作内容以Driver/HAL开发为主,需具备硬件接口评估能力。该职位接受Linux/单片机背景人员转型。

郑伟强dev的专栏 282

线性结构____双链表/栈/队列

双链表 import java.util.LinkedList; public class HelloWorld { public static void main(String []args) { LinkedList<String> lList = new LinkedList<String>(); lList.add("1"); lList.add("...

weixin_30384031的博客 110

3、硬件工程师笔试面试学习汇总——器件篇目录(2025版本)

硬件工程师笔试面试学习

XU157303764的博客 7633

2-8 单链表+双链表+模拟栈+模拟队列

今天给大家用数组来实现链表+栈和队列。

2302_80084329的博客 877

Yolov8-pose关键点检测:训练准备篇 | 自己数据集从labelme标注到生成yolo格式的关键点数据

yolov8-pose关键点检测系列:从数据集标记到生成适合yolo的关键点格式

①答疑群聊服务;②YOLO大模型知识问答系统;③计算机视觉论文生成智能体; 5876

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

栈和队列(Java实现)

栈和队列,算法习题。

2302_81500764的博客 1015

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

【Java】栈和队列详解!!!

栈是一种数据结构,他是一种只允许在一端固定进行插入和删除操作的特殊线性表。先进入的数据被压入栈底最后进入的数据被放在栈顶,需要读出的数据从栈顶开始弹出,按照先入后出的原则。操作:入栈:也称为压栈/进栈,将插入的元素放在栈顶;出栈: 将栈顶的元素进行删除;队列就像日常生活中的排队一样,一端用于插入元素,称为队尾;另一端用于删除元素,称为队头。其遵循的的是先进先出的原则。入队:插入元素在队尾;出队: 删除元素在队头;

2301_80543957的博客 7785

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

队列(Queue)概念+通过单、双链表来模拟队列+环形队列+OJ面试题(用队列实现栈、用栈实现队列、设计环形队列)

队列学习整理

WengJM的博客 787

算法学习——栈和队列的操作(队列实现栈,栈实现队列)

栈的特性:先进后出,后进先出 队列的特性: 先进先出,后进后出 图的宽度有限遍历用栈来实现 => 相当于用栈实现队列 先上代码 /** * 用于栈实现队列 * @author hanhuafeng * @version V1.0 * @description * @date 2020/11/15 */ public class Code06_TwoStacksImplementQueue { /** * 先定义两个栈,模拟出系统给出的栈方法 */ pr

卑微小韩 503

Java—栈与队列

双链表(双向链表)每个节点包含前驱和后继指针,实现栈时可灵活地在头部插入和删除节点(时间复杂度为O(1))。双链表实现队列时,在链表尾部插入节点(入队),在头部删除节点(出队),时间复杂度均为O(1)。队列的典型应用场景包括任务调度(如线程池)、消息队列、广度优先搜索(BFS)等。使用数组实现栈时,需维护一个指向栈顶的指针(通常用。数组大小固定,需处理栈满的情况。问题(即数组前部有空间但尾部已满)。)进行插入和删除操作。的数据结构,只允许在一端(称为。的数据结构,元素从一端(数组实现队列时,需解决。

2401_85340832的博客 455

【DSA】双链表实现队列(代码)

github地址:https://github.com/jobbofhe/Learning_Data_Structure_and_Algorithms /* * @Author: jobbofhe * @Date: 2019-07-29 19:22:56 * @Last Modified by: Administrator * @Last Modified time: 2019-07-29...

春秋繁露 343

算法笔记—链表、队列和栈

链表、队列和栈入门

艺术的博客 787

数据结构 - 栈 与 队列 - (java)

本篇介绍栈和队列,了解栈有顺序栈和链式栈,队列底层是双链表实现的,单链表也可以实现队列,栈和队列的相互实现和循环队列;

m0_69119792的博客 1029

char栈java,关于java中队列和栈的一段代码

//大家谁能具体给我讲讲这段代码是怎么回事//弄的我有点晕//有些地方懂,有些地方又很迷糊class LinkedList //定义双项链表{char data;LinkedList back;LinkedList forward;}interface Access //定义从队列和栈存取操作的接口{void put(char c);char get();}class Queue implemen...

weixin_33129093的博客 264

数据结构(五)——双链表、链式栈、链式队列 及实现

一、双链表 在单链表的基础上再增加一个指向它前驱的指针,就构成了双链表。 所以双链表有三个变量:数据信息info、前驱指针llink、后继指针rlink。   二、双链表操作和实现    由于双链表也为单链表的一种变型,一些相似的操作就没一一列举,可以参

阿修罗道 5088

初识栈和队列

概念 栈:一种特殊的,其只允许在固定的一端进行插入和删除元素操作。出栈入栈的方式为:先进后出栈中存在和链表相似的方法(addfirst,remove等)着一般地实现一个栈会使用数组实现去完成所以需要数组长度elem[],数组中的实际存入长度usedSized链表是否可以实现栈呢?单链表入栈时采用尾插法时时间复杂度会达到O(n),有last存在时O(1),但是出栈时时间复杂度还是会达到O(n)头插法入栈和出栈时间复杂度都会达到O(1)所以使用单链表实现栈要采用头插法。

AKA__Zas的博客 580
上一篇: 【基于链表的软件定时器实现】
下一篇: 用bat脚本编译keil工程
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值