数据结构的队列，链表，栈的基础操作

news2025/1/12 21:01:02

1：队列

 #include <stdio.h>
 #include <stdlib.h>
 #include "./02队列.h"
 
 
 /*
  * function:    创建一个空的队列
  * @param [ in] 
  * @param [out] 
  * @return      
  */
 Sequeue* xinduilie()
 {
     Sequeue* sq = (Sequeue*)malloc(sizeof(Sequeue));         
     if(NULL == sq)
     {
         printf("创建失败!!!\n");
     }
     sq->front = sq->rear = 0;
     return sq;
 }
 /*
  * function:    判满
  * @param [ in] 
  * @param [out] 
  * @return      
  */
 int panman(Sequeue* sq)
 {
     return  (sq->rear+1)%(N+1) == sq->front ? 1:0;
 
 }
 /*
  * function:    入队
  * @param [ in] 
  * @param [out] 
  * @return      
  */
 void rudui(Sequeue* sq,datatype num)
     {
         if(panman(sq))
         {
             printf("插入失败,队列已满\n");
             return;
         }
        sq->data[sq->rear]= num;
        sq->rear = (sq->rear+1)%(N+1);
        printf("入队成功%d\n",num);                       
        return;
    }
/*
 * function:    出队
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void chudui(Sequeue* sq)
{
    if(sq->front == sq->rear)
    {
        printf("队列为空!!!\n");
    }
    Sequeue* num = sq->data[sq->front];
    printf("出队的值为%d\n",num);
    sq->front = (sq->front+1)%N;
    return;
}
/*
 * function:    遍历
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void bianli(Sequeue* sq )
{
    for(int i=sq->front;i!=sq->rear;i=(i+1)%(N+1))
    {
        printf("%d ",sq->data[i]);
    }
    putchar(10);
    return;
}
/*
 * function:    判空
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int pankon(Sequeue* sq)
{                                              
        return sq->rear==sq->front ? 1:0;
}
/*
 * function:    出队
 * @param [ in] 
 * @param [out] 
 * @return      
 
datatype chudui(Sequeue* sq)
{
    if(pankon(sq) == 0)
    {
        printf("出队失败,队列为空\n");
    }
    datatype num = sq->data[sq->front];
    sq->front - (sq->front+1)%(N+1);

    return num;
}
*/

/*
 * function:    计算队列个数
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype jisuan(Sequeue* sq)
{
    return (sq->rear-sq->front+N+1)%(N+1);
}

头文件：

1 #ifndef __02队列_H__
  2 #define __02队列_H__
  3 #define N 5
  4 typedef int datatype ;
  5 typedef struct 
  6 {
  7     int front;
  8     int rear;
  9     datatype data[N+1];
 10 }Sequeue;
 11 Sequeue* xinduilie();//创建一个新的队列
 12 void rudui(Sequeue* sq,datatype num) ;//入队
 13 void chudui(Sequeue* sq);//出队 
 14 int panman(Sequeue* sq);//判满
 15 void bianli(Sequeue* sq );//遍历                                    
 16 int pankon(Sequeue* sq);//判空
 17 datatype jisuan(Sequeue* sq);//计算个数
#endif

主函数：

#include <stdio.h>
#include "./02队列.h"
int main(int argc, const char *argv[])
{
    Sequeue* sq = xinduilie();
    rudui(sq,20); 
    rudui(sq,20);
    rudui(sq,60);
    rudui(sq,27);
    rudui(sq,29);
    chudui(sq);
    bianli(sq);
    printf("队列有效个数:%d\n",jisuan(sq));         
    return 0;
}

结果图：

2：链式队列：

功能代码

 #include <stdio.h>
 #include <stdlib.h>
 #include "./03链式队列.h"
 
 /*
  * function:    创建一个空的链式队列
  * @param [ in] 
  * @param [out] 
  * @return      
  */
 QueueOp* create_linkqueue()
 {
     QueueOp*  fp = (QueueOp*)malloc(sizeof(QueueOp));
     fp->front = (Lnkqueue*)malloc(sizeof(Lnkqueue));
     if(fp->front == NULL)
     {
         printf("创建失败!\n");
         return NULL;
     }
     //初始化,下标地址及有效长度
     fp->front->next = NULL;
     fp->front->msg.len = 0;
     fp->rear = fp->front;
     printf("创建成功!\n");                               
     return fp;
 }
 /*
  * function:    尾插
  * @param [ in] 
 * @param [out] 
 * @return      
 */
void del_list(QueueOp* head,datatype num)
{
    Lnkqueue* temp = (Lnkqueue*)malloc(sizeof(Lnkqueue));

    if(temp == NULL)                                        
    {
        printf("创建失败,节点为空\n");
        return;
    }
    //给链表插入值
    temp->msg.data = num;
    temp->next = NULL;

    temp->next = head->rear->next;
    head->rear->next = temp;
    //更新rear指向
    head->rear = head->rear->next;
    head->front->msg.len++;
    printf("插入成功%d\n",num);
    return;
}
/*
 * function:    判空
 * @param [ in] 
 * @param [out] 
  * @return      
  */
 int isEmpty_list(QueueOp* head)
 {                                                       
     return head->front == head->rear ? 1:0;
 }
 
 /*
  * function:    出栈
  * @param [ in] 
  * @param [out] 
  * @return      
  */
 datatype output_list (QueueOp* head)
 {
     if(isEmpty_list(head))
     {
         printf("队列为空,出队失败\n");
         return (datatype) -1;
     }
     Lnkqueue* temp = head->front->next;
     head->front->next = temp->next;
 
     datatype num = temp->msg.data;
     if(head->front->next == NULL)
     {
         head->rear = head->front;
     }
     head->front->msg.len--;
     return num;
     free(temp);
 }
 /*
  * function:    遍历                              
  * @param [ in] 
  * @param [out] 
  * @return      
  */
 void bianli_list(QueueOp* head)
 {
     while(head->front->next != head->rear->next)
     {
         head->front = head->front->next;
         printf("%d ",head->front->msg.data);
     }
     putchar(10);
     return;
 
 }

主函数

#include <stdlib.h>
#include "./03链式队列.h"
int main(int argc, const char *argv[])
{
        QueueOp* head = create_linkqueue();
        del_list(head,10);
        del_list(head,20);
        del_list(head,30);
        del_list(head,40);
        printf("%d\n",output_list(head));        
        bianli_list(head);
    return 0;
}

头文件函数

#ifndef __03链式队列_H__
#define __03链式队列_H__

typedef int  datatype;
typedef struct lnkq
{
    union
    {
        int len;
        datatype data;
    }msg;
    struct lnkq *next;
}Lnkqueue; 
//用于存储头结点尾节点地址
typedef struct 
{
    Lnkqueue* front;
    Lnkqueue* rear;
}QueueOp;

QueueOp* create_linkqueue();//创建链式列表成功
void del_list(QueueOp* head,datatype num);//尾插
datatype output_list (QueueOp* head);//出栈       
void bianli_list(QueueOp* head);//遍历

#endif

结果图：

3：双向链表

功能代码：

include <stdlib.h>
include <stdio.h>
include "./02双向链表.h"

*
* function:    创建一个双向链表
* @param [ in] 
* @param [out] 
* @return      
*/
oublelist* lianbiao()

   Doublelist* twolianbiao = (Doublelist* )malloc(sizeof(Doublelist));
   if(NULL == twolianbiao)
   {
       printf("创建失败,链表为空\n");
   }
   //初始化双向链表
   twolianbiao->next = NULL;
   twolianbiao->prev = NULL;
   twolianbiao->msg.len = 0;
   return twolianbiao;

*
* function:    头插
* @param [ in] 
* @param [out] 
* @return      
*/
oid headcha(Doublelist* head,datatype num)

   Doublelist* temp = (Doublelist*)malloc(sizeof(Doublelist));
   if(NULL == temp)
   {
       printf("插入失败,创建新结点失败!!!\n");
   }
   temp->msg.data = num;    //给temp赋值
   temp->next = head->next; //修改next指向
   head->next = temp;

   temp->prev = head;//修改prev指向
                                                                                    
   if(temp->next != NULL)
   {
       temp->next->prev = temp;
   }
   printf("头插入成功=%d\n",num);
   head->msg.len++;
   return;

*
* function:    尾插
* @param [ in] 
* @param [out] 
* @return      
*/
oid ledcha (Doublelist* head,datatype num)

   Doublelist* temp =(Doublelist*)malloc(sizeof(Doublelist));
   temp->msg.data = num;//创建新节点并存入值
   temp->next = NULL;

   Doublelist* p = head;
   while(p->next != NULL)
   {
       p=p->next;
   }
   temp->next=p->next;
   p->next = temp;//更改next的指向

   temp->prev = p;//更改prev的指向

   printf("尾插入成功=%d\n",num);
   head->msg.len++;
   return;

*
* function:    头删
* @param [ in] 
* @param [out] 
* @return      
*/
oid headshan(Doublelist* head)

   if(head->next == NULL)
   {
       printf("删除失败,链表为空!!!\n");
   }
   Doublelist* p=head;
   Doublelist* temp = p->next;
   datatype num = temp->msg.data;
   p->next=temp->next;//修改next的指向

   if(temp->next != NULL)
   {
       temp->next->prev = p;
   }
   printf("删除的值=%d\n",temp->msg.data);
   free(temp);
   temp->next = NULL;
   head->msg.len--;

*
* function:    尾删
* @param [ in] 
* @param [out] 
* @return      
*/
oid ledshan(Doublelist* head)

   if(head->next == NULL)
   {
       printf("删除失败,链表为空!!!\n");
   }
   Doublelist* p = head;
   while(p->next != NULL)
   {
       p = p->next;
   }
   datatype num = p->msg.data;
   p->prev->next = p->next;
   printf("删除的值=%d\n",num);
   free(p);
   head->msg.len--;
   return;


*
* function:    判空 
* @param [ in] 
* @param [out] 
* @return      
*/
nt pankon(Doublelist* head)
 return  head->next == NULL ? 1:0 ;}

*
* function:    中间插入
* @param [ in] 
* @param [out] 
* @return      
*/
oid middlecha(Doublelist* head,datatype num,int n)

   if(n<=0)
   {
       printf("插入失败,插入的位置非法!!!\n");
       return;
   }
   Doublelist* p = head;
   for(int i=0;i<n-1;i++)
   {
       p=p->next;
       printf("%d\n",head->msg.len);
         if(NULL == p)
         {                                                           
             printf("插入位置非法!!!\n");
             return;
         }
     }
     Doublelist* temp=(Doublelist*)malloc(sizeof(Doublelist));
     if(NULL == temp)
     {
         printf("创建失败!,插入失败!!!\n");
         return;
     }
     temp->msg.data = num;
     temp->next = NULL;
     temp->prev = NULL;
 
     temp->next = p->next;
     p->next = temp;
 
     temp->prev = p;
     if(temp->next != NULL)
     {
         temp->next->prev = temp;
     }
     printf("在第%d个位置插入的值是%d\n",n,num);
     head->msg.len++;
     return;
 }
 
 /*
  * function:    中间删除
  * @param [ in] 
  * @param [out] 
  * @return      
  */
 void middleshan(Doublelist* head,int n)
 {
     if(head->next ==NULL || head == NULL)
     {
         printf("删除失败,链表为空!!!%d\n");
         return;
     }
     if(n <= 0);
     {
         printf("删除位置非法!!!%d\n",n);
         return;
     }
     Doublelist* p = head;
     for(int i=0;i<n;i++)
     {
         p=p->next;
         if(NULL == p)
         {
             printf("%d删除位置非法!!!\n",n);
             return;
         }
     }
     p->prev->next = p->next;
     if(p->next != NULL)
         {
             p->next->prev = p->next;
         }
     datatype num = p->msg.data;
     free(p);
         head->msg.len --;
     return;
 }

头文件：

#ifndef __02双向链表_H__                                          
#define __02双向链表_H__

typedef int datatype;
typedef struct doublelist
{
    union
    {
        int len;
        datatype data;
    }msg;
     struct doublelist* next;
     struct doublelist* prev;
}Doublelist;


Doublelist* lianbiao();//创建一个空的双向链表
void headcha(Doublelist* head,datatype num);//头插
void ledcha (Doublelist* head,datatype num);//尾插
void headshan(Doublelist* head);//头删
void ledshan(Doublelist* head);//尾删
void middlecha(Doublelist* head,datatype num,int n);//中间插入
void middleshan(Doublelist* head,int n);//中间删除




#endif

主函数main：

 #include <stdio.h>                        
 #include "./02双向链表.h"
 int main(int argc, const char *argv[])
 {
     Doublelist* head = lianbiao();
     headcha(head,10);
     headcha(head,10);
     ledcha(head,90);
     headshan(head);
     ledshan(head);
     ledcha(head,80);
     ledcha(head,60);
     middlecha(head ,50,3);
     middleshan(head,2);
     return 0;
 }

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1819909.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Linux基础IO【II】真的很详细

Linux基础IO【II】真的很详细

目录 一.文件描述符 1.重新理解文件 1.推论 2.证明 2.理解文件描述符 1.文件描述符的分配规则 3.如何理解文件操作的本质&#xff1f; 4.输入重定向和输出重定向 1.原理 2.代码实现重定向 3.dup函数 ​编辑 4.命令行中实现重定向 二.关于缓冲区 1.现象 …
阅读更多...
Ubuntu系统中网易云音乐编译安装

Ubuntu系统中网易云音乐编译安装

项目地址&#xff1a; netease-cloud-music-gtk: Linux 平台下基于 Rust GTK 开发的网易云音乐播放器 目录 1.README.md中按照步骤来 2.安装git 3.报错 sudo apt install cmake sudo apt-get install libdbus-1-dev sudo apt install dnf sudo dnf install gettext 继…
阅读更多...
【Pytorch】一文向您详细介绍 torch.nn.DataParallel() 的作用和用法

【Pytorch】一文向您详细介绍 torch.nn.DataParallel() 的作用和用法

【Pytorch】一文向您详细介绍 torch.nn.DataParallel() 的作用和用法 下滑查看解决方法 &#x1f308; 欢迎莅临我的个人主页 &#x1f448;这里是我静心耕耘深度学习领域、真诚分享知识与智慧的小天地&#xff01;&#x1f387; &#x1f393; 博主简介&#xff1a;985高…
阅读更多...
云原生Kubernetes系列项目实战-k8s集群+高可用负载均衡层+防火墙

云原生Kubernetes系列项目实战-k8s集群+高可用负载均衡层+防火墙

一、Kubernetes 区域可采用 Kubeadm 方式进行安装&#xff1a; 名称主机部署服务master192.168.91.10docker、kubeadm、kubelet、kubectl、flannelnode01192.168.91.11docker、kubeadm、kubelet、kubectl、flannelnode02192.168.91.20docker、kubeadm、kubelet、kubectl、flan…
阅读更多...
【Numpy】一文向您详细介绍 np.trunc()

【Numpy】一文向您详细介绍 np.trunc()

【Numpy】一文向您详细介绍 np.trunc() 下滑即可查看博客内容 &#x1f308; 欢迎莅临我的个人主页 &#x1f448;这里是我静心耕耘深度学习领域、真诚分享知识与智慧的小天地&#xff01;&#x1f387; &#x1f393; 博主简介&#xff1a;985高校的普通本硕&#xff0c;…
阅读更多...
诊所管理系统免费软件哪个好一点？

诊所管理系统免费软件哪个好一点？

不少诊所管理者&#xff0c;想要寻找一款适合自己诊所的免费诊所管理系统。市场上有多个选择&#xff0c;那么&#xff0c;哪个会好一点呢?在选择适合自己诊所的免费诊所管理系统时&#xff0c;考虑系统的易用性、功能全面性、技术支持以及未来可扩展性是非常重要的。下面&…
阅读更多...
算法分析与设计期末考试复习GDPU

算法分析与设计期末考试复习GDPU

重点内容&#xff1a; 绪论&#xff1a; 简单的递推方程求解 1.19(1)(2) 、 教材例题 多个函数按照阶的大小排序 1.18 分治法&#xff1a; 分治法解决芯片测试问题 计算a^n的复杂度为logn的算法&#xff08;快速幂&#xff09; 分治法解决平面最近点对问…
阅读更多...
值得关注的BTC二层 BitlayerLabs，以及好用的bitget钱包

值得关注的BTC二层 BitlayerLabs，以及好用的bitget钱包

值得关注的比特币二层 BitlayerLabs Bitlayer BitlayerLabs 是基于 BitVM 的与比特币安全等效的 Layer2。创新的BitRC-20资产框架为生态系统提供了丰富的资产类别。 为什么推荐bitlayer&#xff1f; Framework Ventures 和 ABCDE Capital 领投&#xff0c;OKX Ventures 等参…
阅读更多...
微软开发基于深度学习的地球大气基础模型-Aurora

微软开发基于深度学习的地球大气基础模型-Aurora

微软研究院的研究人员开发了大气基础模型“Aurora”&#xff0c;https://arxiv.org/abs/2405.13063v1 利用超过一百万小时的多样化天气和气候数据进行训练&#xff0c;能够预测各种大气条件&#xff0c;包括数据有限、变量异构和极端事件&#xff0c;并在全球空气污染和高分辨…
阅读更多...
什么是CPT❓CPT中卖方责任是什么？

什么是CPT❓CPT中卖方责任是什么？

CPT :CPT 运费付至 &#xff08;……指定的目的地&#xff09; 运费付至&#xff08;……指定的地点&#xff09;”是指卖方向其指定的承运人交货&#xff0c;但卖方还必须支付将货物运至目的地的运费。即买方承担交货之后一切风险和其他费用。 “承运人”是指任何人&#xff…
阅读更多...
LabVIEW开发CAN通讯协议

LabVIEW开发CAN通讯协议

在LabVIEW中开发CAN&#xff08;Controller Area Network&#xff09;通讯协议时&#xff0c;需要全面考虑硬件选择、驱动安装、通信配置、错误处理、数据解析和实时性等多个方面。本文详细介绍了在LabVIEW中实现CAN通讯时的关键点和最佳实践&#xff0c;确保系统的稳定性、可靠…
阅读更多...
VScode对比代码功能

VScode对比代码功能

CtrlShiftP选择第一行Compare&#xff0c;当前文件就和选中文件对比改动了。
阅读更多...
梯度下降法、牛顿法、条件熵

梯度下降法、牛顿法、条件熵

梯度下降法、牛顿法&#xff08;可见南瓜书&#xff09; 梯度下降法 深度学习&#xff1a;梯度下降法数学表示式的详细推导 牛顿法 条件熵 在李航老师的书中&#xff0c;第六章最大熵模型这里有个条件熵的定义&#xff1a; 推导如下&#xff1a; 其他一些事实&#xff1a;…
阅读更多...
最小生成树prim算法详解

最小生成树prim算法详解

prim算法解决的是最小生成树问题&#xff0c;即在一个给定的无向图G中求一棵生成树T&#xff0c;使得这棵树拥有图G中的所有顶点&#xff0c;且所有边都是来自图G中的边&#xff0c;并且满足整棵树的边权之和最小。 prim算法的基本思想是对图G设置集合S来存放已被访问的顶点&a…
阅读更多...
IPTCP知识

IPTCP知识

1. IP&#xff1a; IP地址是一个32位的二进制数&#xff0c;通常被分割为4个“8位二进制数”IP地址分类&#xff1a;A类地址、B类地址、C类地址、D类地址、E类地址 A类地址分配给规模特别大的网络使用&#xff0c;B类地址分配给一般的中型网络&#xff0c;C类地址分配给小型网…
阅读更多...
复合机器人以其高度的灵活性和操作效率，展现了显著的优势

复合机器人以其高度的灵活性和操作效率，展现了显著的优势

随着工业4.0的深入推进和智能制造的快速发展&#xff0c;复合机器人作为一种集成移动机器人和工业机器人功能的先进设备&#xff0c;正逐步成为工业自动化领域的新宠。特别是在磁钢上下料的应用中&#xff0c;复合机器人以其高度的灵活性和操作效率&#xff0c;展现了显著的优势…
阅读更多...
6.13作业

6.13作业

自由发挥登录窗口的应用场景&#xff0c;实现一个登录窗口界面 #include "mywidget.h"MyWidget::MyWidget(QWidget *parent): QWidget(parent) {//设置窗口标题this->setWindowTitle("QQ");//设置窗口图标this->setWindowIcon(QIcon("C:/Users/…
阅读更多...
软件性能测试的测试内容和指标介绍，软件性能测试公司推荐

软件性能测试的测试内容和指标介绍，软件性能测试公司推荐

软件性能测试是对软件系统进行评估的一种方法&#xff0c;旨在测量软件在各种条件下的性能表现&#xff0c;以便确定其在实际使用中的可靠性、稳定性和可扩展性。通过性能测试&#xff0c;可以发现软件系统在高负载、并发访问和大数据量处理等方面的性能瓶颈&#xff0c;并提供…
阅读更多...
如何基于 Python 快速搭建 QQ 开放平台 QQ 群官方机器人详细教程（更新中）

如何基于 Python 快速搭建 QQ 开放平台 QQ 群官方机器人详细教程（更新中）

注册 QQ 开放平台账号 账号注册 QQ 机器人&#xff1a;一个机器人可以被添加到 群聊/频道 内对话&#xff0c;QQ 用户也可以直接跟机器人 单独对话。 开发者账号主体要求 单聊对话&#xff1a;【定向邀请】 群聊场景&#xff1a;仅支持企业主体【个人主体暂不支持】 频道场…
阅读更多...
SpringAI学习及搭建AI原生应用

SpringAI学习及搭建AI原生应用

文章目录 一、SpringAI是什么二、准备工作1.GPT-API-free2.AiCore3.eylink 三、对话案例实现1.创建项目2.实现简单的对话 四、聊天客户端ChatClient1.角色预设2.流式响应3.call和stream的区别 五、聊天模型提示词提示词模板 六、图像模型(文生图)七、语音模型1.文字转语音(文生…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023