数据结构-栈、队列和数组

栈

顺序栈

Stack.c

//
// Created by jimeng on 2022/12/28.
//
#include <stdlib.h>
#include <stdio.h>
// 顺序栈
#define MaxSize 50
typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];
    int top;
}SqStack;

// 初始化栈
SqStack* InitStack() {
    SqStack *stack = (SqStack*) malloc(sizeof(SqStack));
    stack->top = -1;
    return stack;
}

// 判断栈空
int StackEmpty(SqStack *stack) {
    if(stack->top == -1) {
        return 1;
    }
    return 0;
}

// 进栈
int Push(SqStack *stack, ElemType e) {
    if(stack->top == MaxSize-1) {
        return 0;
    }
    stack->data[++stack->top] = e;
    return 1;
}

// 出栈
int Pop(SqStack *stack, int *e) {
    if(stack->top == -1) {
        return 0;
    }
    *e = stack->data[stack->top--];
    return 1;
}

// 读栈顶元素
int GetTop(SqStack *stack, int *e) {
    if(stack->top == -1) {
        return 0;
    }
    *e = stack->data[stack->top];
    return 1;
}

// 销毁栈
int DestroyStack(SqStack *stack) {
    free(stack);
    return 1;
}

main.c

#include <stdio.h>
#include "Stack/Stack.c"

int main() {
    printf("Stack\n");
    SqStack *stack = InitStack();
    Push(stack,1);
    Push(stack,2);
    Push(stack,3);
    PrintStack(stack);
    int x = 0;
    Pop(stack, &x);
    printf("Pop: %d\n", x);
    GetTop(stack, &x);
    printf("GetTop: %d\n", x);
    return 0;
}

共享栈

链栈

LinkStack.c

//
// Created by jimeng on 22-12-28.
//
#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;
typedef struct LinkNode {
    ElemType data;
    struct LinkNode *next;
} LinkNode, *LinkStack;

// 初始化栈
LinkStack InitStack() {
    LinkNode *p;
    ElemType data;
    scanf("%d", &data);
    LinkNode *Lhead = NULL;
    while (data!=9999) {
        p = (LinkNode*) malloc(sizeof(LinkNode));
        p->next = Lhead;
        p->data = data;
        Lhead = p;
        scanf("%d", &data);
    }
    return Lhead;
}

//判断栈是否为空
int StackEmpty(LinkStack linkStack) {
    if(linkStack == NULL) {
        return 1;
    }
    return 0;
}

//进栈
LinkStack Push(LinkStack linkStack, ElemType e) {
    LinkNode *top = (LinkNode*) malloc(sizeof(LinkNode));
    top->next = linkStack;
    top->data = e;
    linkStack = top;
    return linkStack;
}

//出栈
LinkStack Pop(LinkStack linkStack, ElemType *e) {
    if(StackEmpty(linkStack) == 1) {
        return NULL;
    }
    LinkNode *top = linkStack;
    if(top!=NULL) {
        *e = top->data;
    }
    linkStack = linkStack->next;
    free(top);
    return linkStack;
}

//读取栈顶元素
int GetTop(LinkStack linkStack, ElemType *e) {
    *e = linkStack->data;
    return 1;
}

//打印栈
void PrintStack(LinkStack linkStack) {
    LinkNode *p = linkStack;
    printf("{ ");
    while (p) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("}\n");
}

main.c 

#include "LinkStack/LinkStack.c"

int main() {
    LinkStack linkStack = InitStack();
    linkStack = Push(linkStack,666);
    PrintStack(linkStack);
    ElemType data;
    linkStack = Pop(linkStack, &data);
    PrintStack(linkStack);
    return 0;
}

队列

队列的顺序存储

#define MaxSize 50
typedef struct {
    int data[MaxSize];
    int front, rear;
}SqQueue;

 可能存在假溢出的情况

循环队列

初始时：front=rear = 0

队首指针进1：front= (front+1)%MaxSize

队尾指针进1：rear= (rear+1)%MaxSize

队列长度：(rear+MaxSize-front)%MaxSize

队满条件：(rear+1)%MaxSize==front

队空条件：front == rear

队列的链式存储

双端队列

栈和队列的应用

括号匹配

后缀表达式

数组和特殊矩阵

压缩存储：为多个值相同的元素只分配一个存储空间，队零元素不分配存储空间。目的是节省存储空间。

特殊矩阵：具有许多相同元素或零元素，并且这些元素分布有一定的规律性。常见的有对称矩阵、上下三角矩阵、对角矩阵。

 

 稀疏矩阵