嵌入式第六课-数据结构和算法—栈与循环队列

1. 数据结构：栈、队列、链表、二叉树。

1.1 数据结构：描述计算机中数据之间的关系和存储方式。

1.2 数据结构分类（有逻辑结构、物理结构、运算结构）

   1.2.1 逻辑结构：数据之间的关系

         1）集合结构：强调总体，不强调数据之间关系。

         2）线性结构：描述数据之间一对一的前后关系。

         3）树形结构：描述数据一对多的关系。

         4）网状结构：数据多对多的关系。

  1.2.2物理结构：数据存放方式

          1）顺序存储结构：数组存储数据。

          2）链式存储结构：链表

  1.2.3运算结构：数据的运算过程

 1.3 栈：基本特性：后进先出（LIFO） 最后放进去的 最先取出 只能操作栈顶。

     1.3.1栈的操作基本原理

            子弹夹上弹退弹。

             栈地址，栈容量，入栈，出栈，栈顶。

示例：

#include <stdio.h>
#include <stdlib.h>

typedef struct stack{
        int *arr;
        int cap;
        int top;
}stack_t;

void init_stack(stack_t *stack,int cap)
{
        stack -> arr = (int*)malloc(cap * sizeof(int));
        stack -> cap = cap;
        stack -> top = 0;
}
void delete_stack(stack_t *stack)
{
        free(stack -> arr);
        stack -> cap = 0;
        stack -> top = 0;
}
int stack_is_full(stack_t *stack)
{
        return ((stack -> top) >= (stack -> cap));
}
int stack_is_empty(stack_t *stack)
{
 return    (!( stack -> top));
}
void stack_push(stack_t *stack,int data)
{
        if(stack -> cap > stack -> top )
        stack -> arr[stack -> top ++] = data;
}
int stack_pop(stack_t *stack)
{
        if(stack -> top > 0 )
        {
                return (stack -> arr[--stack -> top] );
        }
        else
        {
                return 0xffffffff;
        }
}
int get_stack_top(stack_t *stack)
{
        return (stack -> arr[(stack -> top)-1]);
}

int get_stack_size(stack_t *stack)
{
        return (stack -> top);
}
int main(void)
{
        stack_t stack;
        init_stack(&stack,10);
        if(stack_is_empty(&stack))
        {
                printf("the stack is empty\r\n");
        }
        int i=0;
        while(1)
        {

                if(stack_is_full(&stack))
                {
                   printf("\r\nthe stack is full! \r\n");
                    break;
                }
                else
                {
                   printf("push: %d ",i);
                   stack_push(&stack,i);
                   i++;
                }

        }
        while(1)
        {
                if(stack_is_empty(&stack))
                {
                        printf("\r\nthe stack is empty!\r\n");
                        break;
                }
                else
                {
                        printf("pop: %d ",stack_pop(&stack));
                }
        }

        delete_stack(&stack);
   return 0;
}
执行结果：

1.4 队列 :先进先出 （FIFO）

第一个元素称首元素，最后一个元素称尾元素，数据取头加尾

  Linux 系统三大队列：

  消息队列：进程间通信

  工作队列：延后执行

  等待队列：等待被唤醒

循环对列示例：

#include <stdio.h>
#include <stdlib.h>

typedef struct queue{
        int *arr;
        int cap;
        int size;
        int front;
        int rear;
}queue_t;

void queue_init(queue_t *queue , int cap)
{
        queue -> arr   = (int*)malloc(cap*sizeof(queue->arr[0]));
        queue -> cap   = cap;
        queue -> size  = 0;
        queue -> front = 0;
        queue -> rear  = 0;
}

void delete_queue(queue_t *queue)
{
        free(queue -> arr);
        queue -> cap   = 0;
        queue -> size  = 0;
        queue -> front = 0;
        queue -> rear  = 0;
}

int queue_full(queue_t *queue)
{
        return queue -> size >= queue -> cap;
}
int queue_empty(queue_t *queue)
{
        return  !queue -> size;
}
void queue_push(queue_t *queue,int data)
{
        if(queue -> size < queue -> cap)
        {
                if(queue -> rear >= queue -> cap)
                        queue -> rear =0;
                queue -> arr[queue -> rear++] = data;
                queue -> size ++;
        }
}

int queue_pop(queue_t *queue)
{
        if(queue -> front >= queue -> cap)
        {
                queue -> front =0;
        }
        queue -> size --;
        return queue -> arr[queue -> front++];
}

int main(void)
{
        int i=0;
        queue_t queue;
        queue_init(&queue,10);
        while(1)
        {
                if(queue_full(&queue))
                {
                        printf("\r\nthe queue is full \r\n");
                        break;
                }
                else
                {
                        printf("push: %d ",i);
                        queue_push(&queue,i);
                        i++;
                }
        }
        while(1)
        {
                if(queue_empty(&queue))
                {
                        printf("\r\nthe queue is empty\r\n");
                        break;
                }
                else
                {
                        printf("pop: %d ",queue_pop(&queue));
                }
        }

        delete_queue(&queue);

        return 0;
}
执行结果：

嵌入式第五课-C语言结构体  https://blog.csdn.net/qq_21919455/article/details/117262588