老样子,栈和队列的代码分别在Stack和Queue中,有意者自行拿取。需要点这里
一、栈
1.栈的概念及结构
栈:一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶,另一端称为栈底。栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则。
- 压栈:栈的插入操作叫做进栈/压栈/入栈,入数据在栈顶。
- 出栈:栈的删除操作叫做出栈。出数据也在栈顶。
2.栈的实现
栈的实现一般可以使用数组或者链表实现,相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
//支持动态增长的栈
typedef int STDataType
typedef struct StackNode
{
STDataType* a;
int size;
int capacity;
}
二、队列
1.队列的概念及结构
队列:只允许在一端进行插入数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出FIFO(First In First Out) 入队列:进行插入操作的一端称为队尾 出队列:进行删除操作的一端称为队头。
2.队列的实现
队列也可以数组和链表的结构实现,使用链表的结构实现更优一些,因为如果使用数组的结构,出队列在数组头上出数据,效率会比较低。
typededf int QDataType;
typedef struct ListNode
{
QDataType data;
struct ListNode* next;
}QNode;
typedef struct Queue
{
QNode* head;
QNode* tail;
}Queue;
三、栈和队列面试题
typedef char STDataType;
typedef struct Stack
{
STDataType* a;
int Top;
int capacity;
}ST;
void StackInit(ST* ps);
void StackDestory(ST* ps);
void StackPush(ST* ps, STDataType x);
void StackPop(ST* ps);
int StackSize(ST* ps);
bool StackEmpty(ST* ps);
STDataType StackTop(ST* ps);
void StackInit(ST* ps)
{
assert(ps);
ps->a = NULL;
ps->Top = ps->capacity = 0;
}
void StackPush(ST* ps, STDataType x)
{
assert(ps);
//扩容
if (ps->Top == ps->capacity)
{
int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
if (tmp == NULL)
{
perror("realloc is fail\n");
exit(-1);
}
else
{
ps->a = tmp;
ps->capacity = newcapacity;
}
}
ps->a[ps->Top] = x;
++ps->Top;
}
void StackPop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
--ps->Top;
}
void StackDestory(ST* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->Top = ps->capacity = 0;
}
int StackSize(ST* ps)
{
assert(ps);
return ps->Top;
}
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->Top == 0;
}
STDataType StackTop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));
return ps->a[ps->Top - 1];
}
bool isValid(char * s)
{
ST st;
StackInit(&st);
while(*s != NULL)
{
if(*s == '(' || *s == '[' || *s == '{')
{
StackPush(&st,*s);
}
else
{
if(StackEmpty(&st))
{
StackDestory(&st);
return false;
}
char top = StackTop(&st);
StackPop(&st);
if((*s == ']' && top != '[')
|| (*s == ')' && top != '(')
|| (*s == '}' && top != '{'))
{
StackDestory(&st);
return false;
}
}
s++;
}
int flag = StackEmpty(&st);
StackDestory(&st);
return flag;
}
typedef struct {
int* a;
int front;
int back;
int N;
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
if(obj == NULL)
{
perror("malloc is fail\n");
exit(-1);
}
obj->front = obj->back = 0;
obj->N = k+1;
obj->a = (int*)malloc(sizeof(int)*(k+1));
if(obj->a ==NULL)
{
perror("malloc is fail\n");
exit(-1);
}
return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
return obj->front == obj->back;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
return ((obj->back+1)%obj->N) == obj->front;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
if(myCircularQueueIsFull(obj))
return false;
obj->a[obj->back] = value;
obj->back++;
obj->back %= obj->N;
return true;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
return false;
obj->front++;
obj->front %= obj->N;
return true;
}
int myCircularQueueFront(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
return -1;
return obj->a[obj->front];
}
int myCircularQueueRear(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
return -1;
else if(obj->back == 0)
return obj->a[obj->N-1];
else
return obj->a[obj->back-1];
}
void myCircularQueueFree(MyCircularQueue* obj) {
free(obj->a);
free(obj);
obj = NULL;
}
pty(obj))
return -1;
else if(obj->back == 0)
return obj->a[obj->N-1];
else
return obj->a[obj->back-1];
}
void myCircularQueueFree(MyCircularQueue* obj) {
free(obj->a);
free(obj);
obj = NULL;
}