使用动态数组实现队列

动态数组头文件

#pragma once

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

#ifdef __cplusplus
extern "C"{
#endif

	//1. 先把所需要的数据信息结构定义下来
	typedef struct DynamicArray
	{
		//数组存储元素的空间的首地址
		void **addr;
		//存储数据的内存中最大能够容纳多少元素
		int capacity; //容量
		//当前存储数据的内存中有多少个元素
		int size; //大小
	}DynamicArray;

	//初始化数组
	struct DynamicArray *Init_DynamicArray(int capacity);
	//插入元素
	void Insert_DynamicArray(struct DynamicArray *arr, int pos, void *data);
	//遍历
	void Foreach_DynamicArray(struct DynamicArray *arr, void(*_callback)(void *));
	//位置删除
	void RemoveByPos_DynamicArray(struct DynamicArray *arr, int pos);
	//按值删除
	void RemoveByValue_DynamicArray(struct DynamicArray *arr, void *data, int(*compare)(void*, void *));
	//销毁数组
	void Destroy_DynamicArray(struct DynamicArray *arr);

#ifdef __cplusplus
}
#endif

动态数组.c文件

#include"DynamicArray.h"

//初始化数组
struct DynamicArray *Init_DynamicArray(int capacity)
{
	if (capacity <= 0)
	{
		return NULL;
	}

	struct DynamicArray *arr = (struct DynamicArray *)malloc(sizeof(DynamicArray));
	if (NULL == arr)
	{
		return NULL;
	}
	arr->capacity = capacity;
	arr->addr = (void **)malloc(sizeof(void *)*arr->capacity);//二级指针接收一级指针
	arr->size = 0;

	return arr;
}
//插入元素
void Insert_DynamicArray(struct DynamicArray *arr, int pos, void *data)
{

	if (NULL == arr)
	{
		return;
	}

	if (NULL == data)
	{
		return;
	}

	if (pos < 0 || pos > arr->size)
	{
		pos = arr->size;
	}

	//判断空间是否足够
	if (arr->size >= arr->capacity)
	{

		//1. 申请一块更大的内存空间
		int newcapacity = arr->capacity * 2;
		void **newspace = (void **)malloc(sizeof(void *)* newcapacity);

		//2. 将原来空间的数据拷贝到新空间
		memcpy(newspace, arr->addr, sizeof(void *)* arr->capacity);

		//3. 释放原来空间的内存
		free(arr->addr);

		//4. 更新addr指向
		arr->addr = newspace;
		arr->capacity = newcapacity;

	}


	//移动元素，给pos位置空出位置来
	for (int i = arr->size - 1; i >= pos; --i)
	{
		arr->addr[i + 1] = arr->addr[i];
	}

	//将新元素插入到pos位置
	arr->addr[pos] = data;
	arr->size++;
}
//遍历
void Foreach_DynamicArray(struct DynamicArray *arr, void(*_callback)(void *))
{
	if (NULL == arr)
	{
		return;
	}

	if (NULL == _callback)
	{
		return;
	}

	for (int i = 0; i < arr->size; ++i)
	{
		_callback(arr->addr[i]);
	}


}
//位置删除
void RemoveByPos_DynamicArray(struct DynamicArray *arr, int pos)
{

	if (NULL == arr)
	{
		return;
	}

	if (pos < 0 || pos > arr->size - 1)
	{
		return;
	}


	for (int i = pos; i < arr->size - 1; ++i)
	{
		arr->addr[i] = arr->addr[i + 1];
	}


	arr->size--;
}
//按值删除
void RemoveByValue_DynamicArray(struct DynamicArray *arr, void *data, int(*compare)(void*, void *))
{
	if (NULL == arr)
	{
		return;
	}

	if (NULL == data)
	{
		return;
	}

	if (NULL == compare)
	{
		return;
	}


	for (int i = 0; i < arr->size; ++i)
	{
		if (compare(arr->addr[i], data))
		{
			RemoveByPos_DynamicArray(arr, i);
			break;
		}
	}

}
//销毁数组
void Destroy_DynamicArray(struct DynamicArray *arr)
{
	if (NULL == arr)
	{
		return;
	}

	if (arr->addr != NULL)
	{
		free(arr->addr);
		arr->addr = NULL;
	}

	free(arr);
	arr = NULL;
}

队列头文件

#pragma once

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

#define MAX 1024
typedef void* seqQueue;

//初始化队列
seqQueue Init_seqQueue();
//入队
void Push_seqQueue(seqQueue queue,void * data);
//出队
void pop_seqQueue(seqQueue queue);
//返回队头元素
void * front_seqQueue(seqQueue queue);
//返回队尾元素
void * back_seqQueue(seqQueue queue);
//返回队伍大小
int size_seqQueue(seqQueue queue);
//销毁队列
void destroy_seqQueue(seqQueue queue);

队列.c文件

#include "seqQueue.h"

//初始化队列
seqQueue Init_seqQueue()
{
	struct DynamicArray* arr = Init_DynamicArray(MAX);
	return arr;
}
//入队
void Push_seqQueue(seqQueue queue, void * data)
{
	if (queue == NULL)
	{
		return;
	}
	if (data == NULL)
	{
		return;
	}
	struct DynamicArray* myQueue = (struct DynamicArray*)queue;
	if (myQueue->size >= MAX)
	{
		return;
	}
	//入队==尾插
	Insert_DynamicArray(myQueue, myQueue->size, data);
}
//出队
void pop_seqQueue(seqQueue queue)
{
	if (queue == NULL)
	{
		return;
	}
	struct DynamicArray* myQueue = (struct DynamicArray*)queue;
	if (myQueue->size <= 0)
	{
		return;
	}
	RemoveByPos_DynamicArray(myQueue, 0);
}
//返回队头元素
void * front_seqQueue(seqQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}
	struct DynamicArray* myQueue = (struct DynamicArray*)queue;
	if (myQueue->size <= 0)
	{
		return NULL;
	}
	return myQueue->addr[0];
}
//返回队尾元素
void * back_seqQueue(seqQueue queue)
{
	if (queue == NULL)
	{
		return NULL;
	}
	struct DynamicArray* myQueue = (struct DynamicArray*)queue;
	if (myQueue->size <= 0)
	{
		return NULL;
	}
	return myQueue->addr[myQueue->size-1];
}
//返回队伍大小
int size_seqQueue(seqQueue queue)
{
	if (queue == NULL)
	{
		return -1;
	}
	struct DynamicArray* myQueue = (struct DynamicArray*)queue;
	if (myQueue->size <= 0)
	{
		return - 1;
	}
	return myQueue->size;
}
//销毁队列
void destroy_seqQueue(seqQueue queue)
{
	if (queue == NULL)
	{
		return;
	}
	struct DynamicArray* myQueue = (struct DynamicArray*)queue;
	Destroy_DynamicArray(myQueue);
}

测试

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include"DynamicArray.h"
#include "seqQueue.h"

//测试队列
typedef struct Person{
	char name[64];
	int age;
}Person;

void test()
{
	//初始化队列
	seqQueue queue = Init_seqQueue();
	//准备数据
	Person p1 = { "aaa", 15 };
	Person p2 = { "bbb", 16 };
	Person p3 = { "ccc", 17 };
	Person p4 = { "ddd", 18 };
	Person p5 = { "eee", 19 };
	//入队
	Push_seqQueue(queue, &p1);
	Push_seqQueue(queue, &p2);
	Push_seqQueue(queue, &p3);
	Push_seqQueue(queue, &p4);
	Push_seqQueue(queue, &p5);
	Person* p = (Person*)front_seqQueue(queue);
	printf("%s %d\n", p->name, p->age);
	Person* pp = (Person*)back_seqQueue(queue);
	printf("%s %d\n", pp->name, pp->age);
	int size = size_seqQueue(queue);
	printf("%d\n", size);
}

int main(){

	test();

	system("pause");
	return EXIT_SUCCESS;
}