栈和队列 c

数据结构：存储数据的结构

栈 FILO：先进后出
                栈顶标记
操作：     入栈
                出栈
                获取栈顶元素
                判断栈是否为空

队列 FIFO：先进先出
                队头：front
                队尾：tail
                大小：size
操作：     入队
                出队
                获取队头元素
                判断队列是否为空



数组栈、数组队列
链式栈、链式队列

单链表、双向链表、双向循环链表



链式结构：不连续内存数组

数组是一段连续的内存
int array[10] 声明10个长度，连续内存
array[0]
array[1]
array[2]
array[3]
array[4]
array[5]
array[6]
array[7]
array[8]
array[9]

链表内存不是连续的，但是我们可以找到下一段内存，通过指针找

#include <stdio.h>
#include <stdlib.h>
struct Node
{
    int data;
    struct Node* next;
}

int main()
{
    //结构体变量连接结构变量
    struct Node node1 = { 1,NULL };
    struct Node node2 = { 2,NULL };
    struct Node node3 = { 3,NULL };
    node1.next = &node2;
    node2.next = &node3;
    
    //指针
    struct Node *PNode1 = &node1;
    struct Node *PNode2 = &node2;
    struct Node *PNode3 = &node3;
    *PNode1->next = PNode2;
    *PNode2->next = PNode3;
    //指针变成变量的方式
    int a = 1;
    int *p = &a;
    printf("%d\n",*p);  //*p等效a

    int *pMalloc = (int *)malloc(sizeof(int));  //sizeof()返回字节数，int 4字节；malloc() 函数用来动态地分配内存空间，头文件：#include <stdlib.h>
    *pMalloc = 100;
    printf("%d\n",*pMalloc);


    system("pause");  //防止闪屏
    return 0;
}    

链式栈
#include <stdio.h>
#include <stdlib.h>
struct Node  //链表的结构体
{
    int data;  //数据
    struct Node* next;  //指针
}
//创建结点
struct Node* createNode(int data)
{
    struct Node* newNode = (struct Node*)malloc(sizeof(struck Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}    
struct stack
{
    struck Node* stackTop;  //栈顶标记
    int size;  //栈中元素个数
}
//创建栈就是创建一个struct stack的变量
struct stack* createStack()
{
    //创建过程就是初始化过程
    struct stack* myStack = (struck stack*)malloc(sizeof(struck stack));  //动态内存申请
    myStack->stackTop = NULL;
    myStack->size = 0;
    return myStack;
} 

//函数
void push(struct stack* myStack,int data)
{
    //插入的这个结点创建出来
    struck Node* newNode = creatNode(data);
    //入栈操作就是链表表头插入
    newNode->next = myStack->stackTop;
    myStack->stackTop = newNode;
    myStack->size++;
}
//获取栈顶元素
int top(struct stack* myStack
{
    //防御编程
    if(myStack->size == 0)
    {
        printf("栈为空，无法获取栈顶元素/n");
        system("pause");
        returnmyStack->size;
    }
    return myStack->stackTop->data;
}
//出栈，链表的表头删除
void pop(struct stack* myStack)
{
    if(myStack->size == 0)
    {
        printf("栈为NULL，无法出栈\n");
        system("pause");
    }
    else
    {
        struct Node* nextNode = myStack->stackTop->next;
        free(myStack->stackTop);
        myStack->stackTop = nextNode;
        myStack->size--;
    }
}
//万金油函数
int empty(struck stack* myStack)
{
    if(myStack->size == 0)
        return 0;
    return 1;    
}

int main()
{
    struct stack* myStack = createStack();
    push(myStack,1);
    push(myStack,2);
    push(myStack,3);
    while (empty(myStack))
    {
        printf("%d\t",top(myStack));  //top(myStack)获取栈顶元素
        pop(myStack);
    }
    printf("\n");
    system("pause");
    return 0;
}

链式队列
#include <stdio.h>
#include <stdlib.h>
struct Node
{
    int data;
    struct Node* next;
}
struct Node* creatNode(int data)
{
    struct Node* newNode = (struck Node*)malloc(sizeof(struck Node)); 
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}
struct Queue
{
    struct Node* frontNode;
    struct Node* tailNode;
    int size;
}
struct Queue* creatQueue()
{
    struct Queue* myQueue = (struct Queue*)malloc(sizeof(struck Queue));
    
}
int main()
{

}