最近在学习数据结构的路上又学到了新的数据结构,那就是栈和队列,这两个在我理解就是就是附加了更多条件的线性表,下面我们来介绍这两种新的数据结构。
首先是栈,数据结构的基础功能就是增删查改,在栈里面没有改这个操作,增在栈里面叫做压栈/入栈,删,就是出栈,查也是出栈,但是它会返回那个出栈的数据。而且就是栈的规定就是,数据只能从栈顶进入或者出去,遵循先进后出的规则。举个例子:假如我们有一组数据1,2,3,4,5,6按顺序只进行压栈操作,那么我们在栈里面看到的就是图一,入栈出栈的顺序不同,最后导致出栈的数据顺序也不同,如果按图一出栈的话,数据顺序就是6,5,4,3,2,1。但是如果我们先把1,2,3压栈后在出栈一次,再把4,5,6按顺序压栈,最后将所有数据出栈,那我们会得到的数据顺序是,3,6,5,4,2,1。所以只按顺序进行压栈操作的话,出来的数据顺序不一定是原数据顺序的逆序。
下面我们来实现一下栈,我们可以发现他只会在栈顶进行数据的操作,现在我们可以有两种方法来实现它,一种是链表,需要用一个指针来维护尾节点也就是栈顶,还有一种是顺序表的方法,需要用两个变量来维护顺序表的数据尾(栈顶),以及顺序表数组的容量来做一个动态栈。如果用链表的话,我们不需要考虑扩容的问题,但是每次找尾节点会很耗费时间,用顺序表入栈出栈很简便,但需要考虑扩容的问题,不难发现顺序表是我们的最佳选择。
顺序表实现栈代码如下:
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top; // 栈顶
int capacity; // 容量
}Stack;
// 初始化栈
void StackInit(Stack* ps);
// 入栈
void StackPush(Stack* ps, STDataType data);
// 出栈
void StackPop(Stack* ps);
// 获取栈顶元素
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数
int StackSize(Stack* ps);
// 检测栈是否为空,如果为空返回非零结果,如果不为空返回0
int StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);
void StackInit(Stack* ps)
{
ps->a = NULL;
ps->capacity = 0;
ps->top = 0;
}
void StackPush(Stack* ps, STDataType data)
{
assert(ps);
if (ps->capacity == ps->top)
{
int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
ps->a = tmp;
ps->capacity = newcapacity;
}
ps->a[ps->top] = data;
ps->top++;
}
void StackPop(Stack* ps)
{
assert(ps);
assert(ps->top > 0);
ps->top--;
}
STDataType StackTop(Stack* ps)
{
assert(ps);
assert(ps->top > 0);
return ps->a[ps->top - 1];
}
int StackSize(Stack* ps)
{
assert(ps);
return ps->top;
}
int StackEmpty(Stack* ps)
{
assert(ps);
return ps->top == 0;
}
void StackDestroy(Stack* ps)
{
free(ps->a);
ps->a = NULL;
ps->capacity = ps->top = 0;
}
还有就是线性表,它与栈相似,但是它遵循先进先出的规则,头出尾进,放入拿出数据叫入/出队列,我们像上面压栈的方法对队列进行一样的操作可以发现,不管入队列出队列的顺序如何,插入的数据顺序与出队列的数据顺序始终一致。通过分析,队列的实现用链表会更好一点,如果使用顺序表的话,每次出队列,都需要将数据挪动一遍。而列表只需要进行结点的删除就行。而链表需要使用头尾两个指针来维护链表。
下面是链表实现队列的代码,代码如下:
typedef int QDataType;
typedef struct QListNode
{
struct QListNode* next;
QDataType data;
}QNode;
// 队列的结构
typedef struct Queue
{
QNode* _front;
QNode* _rear;
}Queue;
// 初始化队列
void QueueInit(Queue* q);
// 队尾入队列
void QueuePush(Queue* q, QDataType data);
// 队头出队列
void QueuePop(Queue* q);
// 获取队列头部元素
QDataType QueueFront(Queue* q);
// 获取队列队尾元素
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数
int QueueSize(Queue* q);
// 检测队列是否为空,如果为空返回非零结果,如果非空返回0
int QueueEmpty(Queue* q);
// 销毁队列
void QueueDestroy(Queue* q);
void QueueInit(Queue* q)
{
assert(q);
q->_front = NULL;
q->_rear = NULL;
}
void QueuePush(Queue* q, QDataType data)
{
assert(q);
QNode* NewData = (QNode*)malloc(sizeof(QNode));
if (NewData == NULL)
{
perror("malloc fail");
return;
}
NewData->data = data;
NewData->next = NULL;
if (q->_front == NULL)
{
q->_front = NewData;
q->_rear = NewData;
}
else
{
q->_rear->next = NewData;
q->_rear = NewData;
}
}
void QueuePop(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));
if (q->_front->next == NULL)
{
free(q->_front);
q->_front = NULL;
q->_rear = NULL;
}
else
{
QNode* cur = q->_front;
q->_front = q->_front->next;
free(cur);
}
}
QDataType QueueFront(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));
return q->_front->data;
}
QDataType QueueBack(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));
return q->_rear->data;
}
int QueueSize(Queue* q)
{
assert(q);
QNode* cur = q->_front;
int count = 0;
while (cur)
{
count++;
cur = cur->next;
}
return count;
}
int QueueEmpty(Queue* q)
{
assert(q);
return q->_front == NULL;
}
void QueueDestroy(Queue* q)
{
assert(q);
QNode* cur = q->_front;
while (cur != NULL)
{
QNode* next = cur->next;
free(cur);
cur = next;
}
q->_front = NULL;
q->_rear = NULL;
}
以上就是,我对栈和队列的认识,如果有什么不对的地方,请指正。