C语言队列的顺序存储结构

最新推荐文章于 2021-10-31 13:42:12 发布
最新推荐文章于 2021-10-31 13:42:12 发布
阅读量362 收藏
点赞数
分类专栏： 其他 文章标签： 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cris_7/article/details/87669986
版权 
//头文件
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct info {
    int id;
    int age;
    char name[20];
}info_s;

typedef struct AArray {
    void **Array;
    int size;
    int capacity;
}Line_Aarrays;



Line_Aarrays* Line_Array_Init(int capacity_in);
void Insert_Array(Line_Aarrays* p_node, void *value);
void Insert_Pos_Array(Line_Aarrays* p_node, int pos,void *value);
void Foreach_Line_Array(Line_Aarrays *p_node, void(*my_printf)(void *));
void my_printf1(void * node_in);
void Remove_Pos_Array(Line_Aarrays* p_node, int pos);
void Remove_value_Array(Line_Aarrays* p_node, void *value, int(*my_compare)(void*, void*));
int my_compare1(void*, void*);
void Clear_Line_Array(Line_Aarrays *p_node);
void Destroy_Line_Array(Line_Aarrays *p_node);
int Len_Line_Array(Line_Aarrays *p_node);

Line_Aarrays* Line_Array_Init(int capacity_in) {
    Line_Aarrays *Line_Array = (Line_Aarrays*)malloc(sizeof(Line_Aarrays));
    Line_Array -> Array = (void**)malloc(sizeof(void*) * capacity_in);
    Line_Array -> size = 0;
    Line_Array -> capacity = capacity_in;
    return Line_Array;
}

void Insert_Array(Line_Aarrays* p_node, void *value_in) {
    if(p_node == NULL)
        return;
    if(p_node -> size >= p_node -> capacity) {
        void **New_Array = (void **)malloc(sizeof(void*) * p_node -> capacity * 2);
        memcpy(New_Array, p_node -> Array, p_node -> capacity);
        free(p_node -> Array);
        p_node -> Array = New_Array;
        p_node -> capacity = p_node -> capacity * 2;
    }
    p_node -> Array[p_node -> size] = value_in;   
    p_node -> size ++;
}

void Insert_Pos_Array(Line_Aarrays* p_node, int pos,void *value_in) {
    if(p_node == NULL)
        return;
    if(p_node -> size >= p_node -> capacity) {
        void **New_Array = (void **)malloc(sizeof(void*) * p_node -> capacity * 2);
        memcpy(New_Array, p_node -> Array, p_node -> capacity);
        free(p_node -> Array);
        p_node -> Array = New_Array;
        p_node -> capacity = p_node -> capacity * 2;
    }
    if(pos < 0 || pos >= p_node -> size)
        p_node -> Array[p_node -> size] = value_in;
    else {
        for(int i = p_node -> size; i > pos; i--)
            p_node -> Array[i] = p_node -> Array[i - 1];
        p_node -> Array[pos] = value_in;
    }
    p_node -> size ++;
}

void Foreach_Line_Array(Line_Aarrays *p_node, void(*my_printf)(void *)) {
    if(p_node == NULL)
        return;
    for(int i = 0; i < p_node -> size; i++)
        my_printf(p_node -> Array[i]);
}

void my_printf1(void * node_in) {
    info_s* p1 = (info_s*) node_in;
    printf("id : %d, 年龄 ：%d, 姓名：%s\n", p1 ->id, p1 -> age, p1 -> name);
}

void Remove_Pos_Array(Line_Aarrays* p_node, int pos) {
    if(p_node == NULL)
        return;
    if(pos < 0 || pos >= p_node -> size)
        return;
    else {
        for(int i = pos; i < p_node -> size - 1; i++)
            p_node -> Array[i] = p_node -> Array[i + 1];
    }
    p_node -> size --;
}

void Remove_value_Array(Line_Aarrays* p_node, void *value_in, int(*my_compare)(void*, void*)){
    if(p_node == NULL)
        return;
    for(int i = 0; i < p_node -> size; i++) {
        if(my_compare(value_in, p_node -> Array[i])) {
            p_node -> Array[i] = NULL;
            for(int ii = i; ii < p_node -> size - 1; ii++)
                p_node -> Array[ii] = p_node -> Array[ii + 1];
            break;
        }
    }
    p_node -> size --;
}

int my_compare1(void* value_in, void* node_in) {
    int *p1 = (int*)value_in;
    info_s *p2 = (info_s*)node_in;
    if(*p1 == p2 -> id)
        return 1;
    else
        return 0;
}

void Clear_Line_Array(Line_Aarrays *p_node) {
    if(p_node == NULL)
        return;
    free(p_node -> Array);
    p_node -> Array = NULL;
    p_node -> size = 0;
}

void Destroy_Line_Array(Line_Aarrays *p_node) {
    if(p_node == NULL)
        return;
    Clear_Line_Array(p_node);
    free(p_node);
    p_node = NULL;
}

int Len_Line_Array(Line_Aarrays *p_node) {
    if(p_node == NULL)
        return -1;
    return p_node -> size;
}

#include "LineAarray.h"

//使用队列作为队列的内核
typedef void* SeqQueue;

SeqQueue SeqQueue_Init();
void SeqQueue_push(SeqQueue p_node, SeqQueue value_in);
void SeqQueue_pop(SeqQueue p_node, SeqQueue value_in);
void SeqQueue_back(SeqQueue p_node, void(*my_printf)(void *));
void SeqQueue_head(SeqQueue p_node, void(*my_printf)(void *));
void Len_SeqQueue(SeqQueue p_node);
void Destory_SeqQueue(SeqQueue p_node);

SeqQueue SeqQueue_Init() {
    Line_Aarrays *My_Queue = Line_Array_Init(10);
    if (My_Queue == NULL) {
        return NULL;
    }
    return My_Queue;
}
void SeqQueue_push(SeqQueue p_node, SeqQueue value_in) {
    if(p_node == NULL)
        return;
    Line_Aarrays* My_Queue = (Line_Aarrays*)p_node;
    Insert_Pos_Array(My_Queue, 0, value_in);
}
void SeqQueue_pop(SeqQueue p_node) {
    if(p_node == NULL)
        return;
    Line_Aarrays* My_Queue = (Line_Aarrays*)p_node;
    Remove_Pos_Array(My_Queue, My_Queue -> size - 1);
}
void SeqQueue_back(SeqQueue p_node, void(*my_printf)(void *)) {
    if(p_node == NULL)
        return;
    Line_Aarrays* My_Queue = (Line_Aarrays*)p_node;
    if (My_Queue -> size == 0)
        return;
    my_printf(My_Queue -> Array[0]);
}
void SeqQueue_head(SeqQueue p_node, void(*my_printf)(void *)) {
    if(p_node == NULL)
        return;
    Line_Aarrays* My_Queue = (Line_Aarrays*)p_node;
    if (My_Queue -> size == 0)
        return;
    my_printf(My_Queue -> Array[My_Queue -> size - 1]);
}
void Len_SeqQueue(SeqQueue p_node) {
    if(p_node == NULL)
        return;
    Line_Aarrays* My_Queue = (Line_Aarrays*)p_node;
    printf("队列的长度为：%d\n", Len_Line_Array(My_Queue));
}
void Destory_SeqQueue(SeqQueue p_node) {
    if(p_node == NULL)
        return;
    Line_Aarrays* My_Queue = (Line_Aarrays*)p_node;
    Destroy_Line_Array(My_Queue);
}

int main() {

    printf("---开始创建队列---\n");
    SeqQueue Queue_head = SeqQueue_Init();
    printf("---队列创建完毕---\n");
    
    info_s n1 = {1, 21, "花木兰"};
    info_s n2 = {2, 21, "凯皇"};
    info_s n3 = {3, 21, "百里守约"};
    info_s n4 = {4, 19, "百里玄策"};
    info_s n5 = {5, 22, "苏烈"};
    info_s n6 = {6, 20, "李信"};

    printf("---开始入队列--\n");
    SeqQueue_push(Queue_head, &n1);
    SeqQueue_back(Queue_head, my_printf1);
    SeqQueue_push(Queue_head, &n2);
    SeqQueue_back(Queue_head, my_printf1);
    SeqQueue_push(Queue_head, &n3);
    SeqQueue_back(Queue_head, my_printf1);
    SeqQueue_push(Queue_head, &n4);
    SeqQueue_back(Queue_head, my_printf1);
    SeqQueue_push(Queue_head, &n5);
    SeqQueue_back(Queue_head, my_printf1);
    SeqQueue_push(Queue_head, &n6);
    SeqQueue_back(Queue_head, my_printf1);
    printf("---入队列完毕---\n");
    Len_SeqQueue(Queue_head);

    printf("---开始出队列--\n");
    SeqQueue_head(Queue_head, my_printf1);
    SeqQueue_pop(Queue_head);
    SeqQueue_head(Queue_head, my_printf1);
    SeqQueue_pop(Queue_head);
    SeqQueue_head(Queue_head, my_printf1);
    SeqQueue_pop(Queue_head);
    SeqQueue_head(Queue_head, my_printf1);
    SeqQueue_pop(Queue_head);
    SeqQueue_head(Queue_head, my_printf1);
    SeqQueue_pop(Queue_head);
    SeqQueue_head(Queue_head, my_printf1);
    SeqQueue_pop(Queue_head);
    printf("---出队列完毕---\n");
    Len_SeqQueue(Queue_head);

    printf("---开始销毁队列---\n");
    Destory_SeqQueue(Queue_head);
    Queue_head = NULL;
    printf("---销毁队列完毕---\n");

    system("pause");
    return 0;
}
【数据结构】顺序队列的实现（C语言）
( :3 )
09-18 1483
队列的基本概念及其描述 队列是一种特殊的线性表，它的特殊性在于队列的插入和删除操作分别在表的两端进行。 插入的那一端称为队尾，删除的那一端称为队首。队列的插入操作和删除操作分别称为进队和出队。 先进先出（First In First Out） 顺序队列要掌握以下操作： 1、队列的初始化 2、判断队列是否为空 3、打印队列的节点值 4、取得队列的队首节点值 5、队列的插入操作（从队...
C语言数据结构-4.队列的顺序及链式存储结构
Chunix的专栏
07-27 986
1.顺序参考代码
c语言队列的顺序存储结构
qq_40741513的博客
09-02 437
这是根据顺序表实现的队列的顺序存储结构 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct node { int data[100]; int size; }node,*linklist; void create_queue(linklist *l)//队列的建立 { (*l)=(nod...
队列的顺序存储结构（C语言）
weixin_44922609的博客
05-18 235
队列的顺序存储结构 基本操作：初始化队列，判断队列空，入队操作，出队操作，输出队列 （C语言代码，用到引用建立的C++project） #include <iostream> #include<stdlib.h> #define maxsize 10 typedef struct{//定义队列 int data[maxsize]; int front,rear; }sqqueue; void initqueue(sqqueue &q){//初始化队列 q.
队列的C语言实现：顺序存储
aquaria_pp的博客
03-24 222
/* * 循环队列 */ #include<stdio.h> #include<stdlib.h> typedef int bool; #define true 1 #define false 0 #define ERROR -1 #define INITSIZE 4 typedef struct { int *base; int front; int r...
队列 c语言 顺序存储结构,顺序队列一
weixin_42131367的博客
05-17 245
1.队列的概念在开始前，请牢记这句话：队列是一个先进先出的数据结构。队列(queue)是限定在表的一端进行插入，表的另一端进行删除的数据结构，如同栈的学习，请联系前文所学链表，试想一个单链表，我们只能对他的链表表尾进行插入，而只能对链表的表头进行结点的删除，其余一切的操作均不允许，这样强限制性的“链表“，就是我们所说的队列。让我们重新理顺一下定义：队列是一个线性的数据结构，规定这个数据结构只允许在...
队列顺序存储&链式存储.rar
04-12
本资源“队列顺序存储&链式存储.rar”提供了浙江大学在中国大学MOOC上《数据结构》课程中关于队列实现的源代码，主要包含两种存储方式：顺序存储和链式存储。 队列是一种先进先出（First In First Out, FIFO）的...
顺序存储和链式存储的泛型队列_C语言项目
04-12
本项目专注于实现顺序存储和链式存储的泛型队列，使用C语言作为编程工具，旨在提供灵活且高效的操作接口。下面我们将深入探讨相关知识点。 首先，队列是一种先进先出（First In First Out, FIFO）的数据结构，它的...
C语言实现队列源码，包含顺序队列，链式队列，循环队列，亲测可用
04-25
在C语言中，我们通常使用结构体来定义队列，包括存储队列元素的数组、队头和队尾的索引等信息。入队操作需要检查队列是否已满，而出队操作则需检查队列是否为空。在实际编程中，为了提高效率，一般会采用双指针的...
顺序存储结构的队列（C语言）
诚朴勇毅
01-03 587
队列是一种特殊的线性表，它的特殊性体现在，它只能够从一段进，从另一端出，遵循先入先出的原则。这种独特的规则，可以运用在程序设计中的很多地方，非常的巧妙。 下面，我用C语言来实现了循环队列。 /*******************************************************************/ //描述：队列的顺序存储结构，该队列为循环队列，队列的创建，插入，
C语言实现队列的顺序存储
linry的博客
01-08 734
队列  #1. 队列不得和栈比较，栈是一种先进后出的线性表，而队列是一种先进先出 (first in first out,缩写 FIFO) 的线性表.  #2. 它只允许在表的一端进行插入，而在另一端删除元素。  #3. 在队列中插入的一端为队尾（rear),允许删除的一端为队头（front)。     这里我们实现队列的顺序存储， 实现ADT中基本操作 Status InitQueue(SqQ...
用C语言实现队列的顺序存储结构
761899457@qq.com
07-07 490
队列的顺序存储结构算是数据结构里面比较简单的一块知识点了，他的代码也很简单 代码如下： #include<stdio.h> #define elemtype int #define maxsize 30 #define false 0 #define true 1 #define bool char //循环队列 typedef struct { elemtype data[maxsize]; int front ,rear; }SqQueue; void initQueu
插入排序—直接插入排序(Straight Insertion Sort)
wgiyq的博客
01-07 1189
插入排序—直接插入排序(Straight Insertion Sort) 将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。
c实现队列的顺序存储
dabing113的博客
03-30 211
// // QUEUE.c // duizhanduilie // // 队列的顺序存储结构 #include <stdio.h> #define M 100 #define QElemType int //初始化队列 void INITIALQ(int front,int rear); //测试队列是否为空 int EMPTYQ(int front,int rear); //...
队列的顺序存储结构算法——C语言版
鹅弍的博客
03-20 293
队列的顺序存储结构算法——C语言版 队列包括栈的头尾指针就是形象的指针，并不是实际的指针 进队：头指针不动，尾指针变化，这是因为队列入队是头不变一直是尾巴变 代码实现： #include<stdio.h> #include<stdlib.h> #define MaxSize 10 typedef struct A { int data[MaxSize]; ...
C语言顺序存储队列
weixin_46654029的博客
10-25 293
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 C语言顺序存储队列一、什么是队列的顺序存储二、程序 一、什么是队列的顺序存储 1、队列是只允许在一端进行插入操作，另一端进行删除操作的线性表。 2、使用数组来存取队列元素的结构叫队列的顺序存储结构。 3、假设一个队列有n个元素，则顺序存储的队列需要建立一个大于n的数组，并把队列的所有元素存储在数组的前n个单元，数组下标为0的一端即为对头。 （1）入队，就是在队尾追加一个元素，不需要移动任何元素，所以时间复杂度为O(1). （2）出队是在队
数据结构严薇敏——队列的顺序存储（C语言）
Attention_0的博客
07-28 590
和栈相反，队列是一种先进先出的线性表。只能在表的一端进行插入，另一端进行删除。（类似与我们排队买东西，先到先得） 队列中，允许插入的一端叫做队尾，允许删除的一端叫队头。 代码实现 ： 顺序数据结构定义为： typedef int ElemType; typedef struct SqQueue { ElemType data[MAX_SIZE]; int size; ...
队列顺序存储C语言实现
Claire_cf的博客
08-20 525
参考资料为《大话数据结构》 typedef int ElemType; typedef struct { ElemType data[MAXSIZE]; int front, rear; }SqQueue; //让front指向队头元素，rear指向队尾元素的下一个位置（无值） 1、初始化 //初始化 void InitQueue(SqQueue* Q) { Q->front = 0; Q->rear = 0; } 2、清除队列 //清除队列 void ClearQueue(SqQu
队列的顺序存储结构C++实现
weixin_43246440的博客
11-03 387
/* * @Description: * @版本: 2.0 * @作者: jianwen * @Date: 2019-11-03 14:40:23 * @LastEditors: jianwen * @LastEditTime: 2019-11-03 15:37:32 */ #include<iostream> using namespace std; #define ...
c语言队列的顺序存储实现
weixin_45846799的博客
10-31 428
#include <stdio.h> #include <malloc.h> #include <stdbool.h> //队列的顺序存储实现 typedef int Position; struct QNode { int *Data; Position Front,Rear;//定义队列的头部以及尾部 int MaxSize;//数组的大小 }; typedef struct QNode *Queue; Queue CreateQueue(int Ma
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值