栈和队列的线性表结构

栈和队列的线性表结构

栈

只允许在表的一端进行插入和删除的线性表
LIFO

主要操作:

1. void InitStack(Stack& S);
2. void Push(Stack& S, SElemType x);
3. void Pop(Stack& S, SElemType& x);
4. void GetTop(Stack& S, SElemType& x);
5. int StackEmpty(Stack& S);
6. int StackFull(Stack& S);
7. int StackSize(Stack& S);

具体实现代码:(聪明如你,不用解释)

#define initSize 20
typedef int SElemType;
typedef struct{
    SElemType *elem;
    int maxSize, top;
}Stack;

void InitStack(Stack& S){
    S.elem = (SElemType*)malloc(initSize*sizeof(SElemType));
    if(S.elem == NULL) exit(1);
    S.maxSize = initSize;
    S.top = -1;
}

void Push(Stack& S, SElemType x){
    if(S.top == S.maxSize-1) return 0;
    S.elem[++S.top] = x;
    return 1;
}

void Pop(Stack& S, SElemType x){
    if(S.top == -1) return 0;
    x = S.elem[S.top--];
    return 1;
}

void GetTop(Stack& S, SElemType x){
    if(S.top == -1) return 0;
    x = S.elem[S.top];
    return 1;
}

void StackEmpty(Stack& S){
    return S.top == -1;
}

void StackFull(Stack& S){
    return S.top == S.maxSize;
}

void StackSize(Stack& S){
    return S.top + 1;
}

以上操作在c++STL有对应的实现,分别为:(#include<stack>)

1. stack<SElemType> S
2. push(x)
3. pop()
4. top()
5. empty()
6. –
7. size()

---

队列

允许在表的一端插入,在另一端删除的线性表
FIFO

主要操作:

1. void InitQueue(Queue& Q);
2. int EnQueue(Queue& Q, QElemType x);
3. int DeQueue(Queue& Q, QElemType x);
4. int GetFront(Queue& Q, QElemType x);
5. int QueueEmpty(Queue& Q);
6. int QueueFull(Queue& Q);
7. int QueueSize(Queue& Q);

具体实现代码:

#define maxSize 20
typedef int QElemType;
typedef struct{
    QElemType elem[maxSize];
    int front, rear;
}Queue;

void InitQueue(Queue& Q){
    Q.front = Q.rear = 0;
}

int EnQueue(Queue& Q, QElemType x){
    if((Q.rear+1) % maxSize == Q.front) return 0;
    Q.elem[Q.rear] = x;
    Q.rear = (Q.rear+1) % maxSize;
    return 1;
}

int DeQueue(Queue& Q, QElemType x){
    if(Q.rear == Q.front) return 0;
    x = Q.elem[Q.rear];
    Q.front = (Q.front+1) % maxSize;
    return 1;
}

int GetFront(Queue& Q, QElemType x){
    if(Q.rear == Q.front) return 0;
    x = Q.elem[Q.front];
    return 1;
}

int QueueEmpty(Queue& Q){
    return Q.front == Q.rear;
}

int QueueFull(Queue& Q){
    return (Q.rear+1) % maxSize == Q.front;
}

int QueueSize(Queue& Q){
    return (Q.rear - Q.front + maxSize) % maxSize;
}

以上操作在c++STL有对应的实现,分别为:(#include<queue>)

1. queue<QElemType> Q
2. push(x)
3. pop()
4. front()
5. empty()
6. –
7. size()

结束语:

这个你说他重要吗,他不是特别重要
但是你说他不重要吗,他确实
其实知道它的底层原理了,会使用c++的STL就行了
看看就好
所有图片来自网络