c语言结构体怎么判断是不是为空
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了c语言结构体怎么判断是不是为空相关的知识,希望对你有一定的参考价值。
(1)若是指向结构体的指针,则判断其是否为NULL;(2)若是结构体的变量,由于在定义初始化变量时已分配内存,所以其只有数据有效和无效之分,没有空值之说,若是结构体内有指针,则判断同(1)。 参考技术A 只能判断它里面所有的值了。 参考技术B 先请问你是要判断textbox控件是否为空吗?
新手向C语言实现特殊数据结构——队列(含用两个队列实现栈)
目录
前言
使用单向无头不循环链表实现队列。
队列:符合先进先出逻辑的特殊数据结构。
不适合用数组来实现,虽然入队便捷但是出队时需要挪动队首后的所有元素,效率略低。
单向不循环链表对于找尾的效率确实低,但是可以在结构体中定义出队首节点和队尾节点,分别管理使得入队和出队的效率都高。所以就需要定义两个结构体,一个管理节点的内容,一个管理整个队列。
建议先跳转到第三部分阅读结构体定义的代码,以便后续便于理解。
关于改变链表头节点的方式:
1、二级指针(传指针解引用改变)
2、返回新头(接受改变值)
3、带哨兵位的头节点(本质上不会改变头节点)
4、结构体包一起(大结构体一级指针改变)
此次选择第四种方式。
可能这时候就会有同学这样问了:为什么在实现单向不循环链表的时候不把结构体包一起呢?这样不就解决了找尾效率低的问题吗?
哎,这位同学就年轻了啊。你这样解决了尾插的问题,但是能解决尾删的问题吗?单向不循环链表中时不能通过一个节点找到上一个节点的。也就是尾删了后还是要找尾···
一、易错接口详解
1.1 出队
出队算法:法一:保存下一个节点为next,再删除。
法二:保存要删除的节点为del,把头结点赋值为新节点,然后free掉del
此次选择法一。
需要注意队列为空时调用此接口会出现非法访问的错误,所以需要提前断言报错。
这里把判断是否为空的功能封装成一个函数,详情请跳转至第二部分查看。
特殊情况:当链表删除掉最后一个节点时,ptail会成为野指针。
所以仅有一个节点时就直接free
掉,再将头指针和尾指针都赋值为NULL
。
正常情况下,出队时记得保留队头节点的下一节点的地址,以便头节点迭代。
void QueuePop(Queue* pq)
assert(pq);
assert(!QueueEmpty(pq));
if (pq->phead->next == NULL)
free(pq->phead);
pq->phead = pq->ptail = NULL;
else
QueueNode* next = pq->phead->next;
free(pq->phead);
pq->phead = next;
1.2 入队
入队算法:为新的头节点开辟新空间,并插入有效数据。之后的步骤相当于链表的尾插。
但是需要注意特殊情况:队列中没有节点时需要直接把头尾节点都改为新节点。
void QueuePush(Queue* pq, QDataType x)
assert(pq);
QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
if (newnode == NULL)
printf("malloc fail\\n");
exit(-1);
newnode->data = x;
newnode->next = NULL;
//新节点初始化结束
if (pq->ptail == NULL)
pq->phead = pq->ptail = newnode;
else
pq->ptail->next = newnode;
pq->ptail = newnode;
二、 简单接口的实现
2.1 队列的初始化
算法:将头指针和尾指针都赋值为NULL
void QueueInit(Queue* pq)
assert(pq);
pq->phead = pq->ptail = NULL;
2.2 队列节点计数
int QueueSize(Queue* pq)
assert(pq);
int count = 0;
QueueNode* cur = pq->phead;
while (cur)
count++;
cur = cur->next;
return count;
关于链表计数的接口,如果调用频繁的话就可以在大结构体Queue
中加入一个计数成员,入队或出队时修改。如果调用不频繁,就直接在接口中进行计算。
2.3 队列的销毁
算法:利用创建的新指针cur
从头走到尾,走到一个节点就删除一个节点,在删除前还需要保留cur
指针的下一个节点地址,以便cur
指针迭代。最后还不要忘了将头节点的指针phead
和为节点的指针ptail
指向NULL
。
void QueueDestory(Queue* pq)
assert(pq);
QueueNode* cur = pq->phead;
while (cur)
QueueNode* next = cur->next;
free(cur);
cur = next;
pq->phead = pq->ptail = NULL;
2.4 判断队列是否为空
bool QueueEmpty(Queue* pq)
assert(pq);
return pq->phead == NULL && pq->ptail == NULL;
2.5 返回队头数据
QDataType QueueFront(Queue* pq)
assert(pq);
assert(!QueueEmpty(pq));
return pq->phead->data;
2.6 返回队尾数据
QDataType QueueBack(Queue* pq)
assert(pq);
assert(!QueueEmpty(pq));
return pq->ptail->data;
三、头文件引用、函数与结构体定义
#include<assert.h>
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
typedef int QDataType;
typedef struct QueueNode
struct QueueNode* next;
QDataType data;
QueueNode;
typedef struct Queue
QueueNode* phead;
QueueNode* ptail;
Queue;
void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
int QueueSize(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
四、拾枝杂谈
4.1 队列接口调用方式
首先创建一个大结构体Queue
的对象q
,再把对象初始化,再入队,打印的时候必须打印一个队首元素就将队首元素进行出队,直至队列为NULL
时即可将队中所有元素打印完成,最终销毁整个队列,避免内存泄漏。
void Test2()
Queue q;
QueueInit(&q);
QueuePush(&q, 1);
QueuePush(&q, 2);
QueuePush(&q, 3);
QueuePush(&q, 4);
while (!QueueEmpty(&q))
printf("%d ", QueueFront(&q));
QueuePop(&q);
QueueDestory(&q);
4.2 用两个队列实现栈
队列的特点:先进先出
栈的特点:后进先出
算法总结如下:
1、两个队列一个有数据,另外一个为空。
2、入栈时,向不为空的队列中添加数据。
3、出栈时,将有数据的队列中的size - 1个数据导入到为空的队列,把剩下的一个数据出队——即可实现“出栈”。
由于c语言不能像C++那样使用栈的库函数,所以以下代码利用了上文中已经实现好的接口。
首先是定义一个代表栈的结构体,里面的成员为两个队列。
typedef struct
Queue q1;
Queue q2;
MyStack;
接下来实现创建栈的接口,需要注意不可在此接口中利用临时变量返回所创建栈的地址,因为临时变量会在函数调用结束时销毁,故利用动态开辟内存函数malloc
开辟一个栈结构体的对象,再调用已定义好的队列初始化接口将其内部的两个队列进行初始化。
MyStack* myStackCreate()
MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
QueueInit(&pst->q1);
QueueInit(&pst->q2);
return pst;
入栈的实现:其本质是入队,但是入队时需要保证向不为空的队列中添加数据,这时候QueueEmpty
接口可以帮助快速判断哪一个为空队。
这时候有同学可能会问为啥“入栈”的时候非要往不为空的队列里面加数据呢?
void myStackPush(MyStack* obj, int x)
if(!QueueEmpty(&obj->q1))
QueuePush(&obj->q1, x);
else
QueuePush(&obj->q2, x);
出栈的实现:将非空队列的size - 1个元素都入队到另一个队列中,再删除剩下的一个元素。
int myStackPop(MyStack* obj)
Queue* emptyQ = &obj->q1;
Queue* nonemptyQ = &obj->q2;
if(!QueueEmpty(&obj->q1))
emptyQ = &obj->q2;
nonemptyQ = &obj->q1;
while(QueueSize(nonemptyQ) > 1)
QueuePush(emptyQ, QueueFront(nonemptyQ));
QueuePop(nonemptyQ);
int top = QueueFront(nonemptyQ);
QueuePop(nonemptyQ);
return top;
取栈顶元素:相当于返回非空队列的队尾元素,直接调用已经实现好的接口即可。
int myStackTop(MyStack* obj)
if(!QueueEmpty(&obj->q1))
return QueueBack(&obj->q1);
else
return QueueBack(&obj->q2);
判断栈是否为空:只需要判断两个队列是否同时为空即可。
bool myStackEmpty(MyStack* obj)
return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
销毁栈:调用已有接口分别将两个队列销毁,再释放掉表示栈的结构体对象的空间。
void myStackFree(MyStack* obj)
QueueDestory(&obj->q1);
QueueDestory(&obj->q2);
free(obj);
obj = NULL;
4.3 循环队列
4.3.1 循环队列算法图解
算法总结:
给出既定的空间数,删除数据时不会删除已有节点的空间,而是让头节点指针向后走,插入数据时,让尾节点向后走。
当头节点和尾节点指向同一位置时,循环队列为空。
当尾节点的下一节点指向头节点时,循环队列为满。
需要开辟比既定空间数多一个单位空间,以便区别循环队列为空和为满的状态。
4.3.2 代码实现
4.3.2.1 循环队列的结构体定义
利用的是匿名结构体,没有一开始就给出结构体名称,而是直接typedef
重定义匿名结构体的名字,使用时同样不需要再加上struct
了。
利用的数据结构是顺序表。如果想用链表实现,需要用到循环链表,但是在判断头节点和尾节点的关系时不太方便。
front
为头节点的下标,rear
为尾节点的下标。
k
为循环队列的空间大小。
typedef struct
int* a;
int front;
int rear;
int k;
MyCircularQueue;
4.3.2.2 判断循环队列是否为空
当头节点下标和尾节点下标相等时循环队列为空。
bool myCircularQueueIsEmpty(MyCircularQueue* obj)
return obj->front == obj->rear;
4.3.2.3 判断循环队列是否已满
当尾节点的下一个位置是头节点时,循环队列已满。
但是需要注意的是,rear
出现在顺序表末尾时,front
在顺序表之首,rear
前面的位置实质上是顺序表越界的位置,要使rear+1
后的数值仍然能和front
的数值有效比对,就将rear+1
对k+1
取余。
如下图可以对代码进行简单验证。
注:黑色数字为队列中数据,蓝色数字为顺序表的下标。
bool myCircularQueueIsFull(MyCircularQueue* obj)
return (obj->rear + 1) % (obj->k + 1) == obj->front;
4.3.2.4 循环队列的初始化
给上一个参数k
,会创建k + 1
个数据的空间,以便区分队列的空与满的状态。
MyCircularQueue* myCircularQueueCreate(int k)
MyCircularQueue* q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
q->a = (int*)malloc(sizeof(int)*(k + 1));
q->front = 0;
q->rear = 0;
q->k = k;
return q;
4.3.2.5 循环队列的入队
首先需要判断队列是否已满,若满就返回false
若没有满则在尾节点处插入数据,再让尾节点指针向后跳。
特别注意:当尾节点指针所指向位置是顺序表末尾时,需要让其重新回到开头,即顺序表下标为0
处。
插入完成返回true
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
if(myCircularQueueIsFull(obj))
return false;
obj->a[obj->rear] = value;
obj->rear++;
if(obj->rear == obj->k + 1)
obj->rear = 0;
return true;
4.3.2.6 循环队列的出队
首先需要判断队列是否为空,若为空就返回false
若不为空,则让头指针向前跳一步。
但是需要注意如果头指针已经指向顺序表的尾部了,再往前跳就越界了,所以需要将front
的值对k+1
取余。
这样如此,就算是front
为k+1
了,也可以立刻返回头指针的位置。
bool myCircularQueueDeQueue(MyCircularQueue* obj)
if(myCircularQueueIsEmpty(obj))
return false;
obj->front++;
obj->front %= obj->k + 1;
return true;
4.3.2.7 取队头的值
判断是否为空队后返回头指针所指向的数据即可。
int myCircularQueueFront(MyCircularQueue* obj)
if(myCircularQueueIsEmpty(obj))
return -1;
return obj->a[obj->front];
4.3.2.8 取队尾的值
取队尾的值即为取队尾前一个下标的值,即下标为rear - 1
的值。
但需要注意若是rear
的下标为0,队尾的值应该是下标为k
的值。
int myCircularQueueRear(MyCircularQueue* obj)
if(myCircularQueueIsEmpty(obj))
return -1;
int prevRear = obj->rear - 1;
if(0 == obj->rear)
prevRear = obj->k;
return obj->a[prevRear];
4.3.2.9 删除循环队列
释放循环队列结构体对象中的顺序表,释放对象指针本身。
void myCircularQueueFree(MyCircularQueue* obj)
free(obj->a);
obj->a = NULL;
free(obj);
obj = NULL;
以上是关于c语言结构体怎么判断是不是为空的主要内容,如果未能解决你的问题,请参考以下文章