• DSP_TMS320F28335_队列与栈

    说起队列和栈，链表+动态内存分配的方式，是比较常见的方式，最近项目下需要在dsp上面使用队列和栈两种数据结构，所有就使用链表+动态内存分配的方式实现了一下，但是调试的过程中发现运行的时候总是在动态内存分配的位置出bug，动态内存分配malloc总是分配失败，返回空指针，尝试修改cmd的配置后，也仍然没有解决问题。思来想去还是用数组的方式来实现队列和栈，结果性能出奇的稳定，所以本博客记录一下用数组实现队列和栈的代码。

    参考链接：数据结构：栈和队列(Stack & Queue)【详解】-CSDN博客

    参考链接：c语言底层数组的方式实现栈和队列_c语言树和队列的底层实现是什么-CSDN博客

    目录

    1  队列

    2 栈

    1  队列

    queue.h

    1. #ifndef USERPROGRAM_QUEUE_QUEUE_H_
    2. #define USERPROGRAM_QUEUE_QUEUE_H_
    3.  
    4. #include 
    5.  
    6. #define QUEUE_MAX_SIZE 500
    7. /*--------------- 单个Uint16队列 ---------------*/
    8. typedef struct _queue{
    9.     int size;
    10.     int front;
    11.     int rear;
    12.     Uint16 data[QUEUE_MAX_SIZE];
    13. } queue;
    14.  
    15. void queue_init(queue *q);
    16. int enqueue(queue *q, Uint16 value);
    17. int dequeue(queue *q, Uint16 *value);
    18. int is_queue_empty(queue *q);
    19.  
    20. extern queue scib_rx_queue;
    21. extern queue scib_tx_queue;
    22.  
    23. #endif /* USERPROGRAM_QUEUE_QUEUE_H_ */

    queue.c 

    1. #include 
    2.  
    3. queue scib_rx_queue;
    4. queue scib_tx_queue;
    5.  
    6. void queue_init(queue *q){
    7.     q->size     = 0;
    8.     q->front    = 0;
    9.     q->rear     = -1;
    10. }
    11.  
    12. int enqueue(queue *q, Uint16 value){
    13.     if(q->size == QUEUE_MAX_SIZE){
    14.         return 0;
    15.     }
    16.     q->rear++;
    17.     q->data[q->rear] = value;
    18.     q->size++;
    19.     return 1;
    20.  
    21. }
    22.  
    23. int dequeue(queue *q, Uint16 *value){
    24.     if(q->size == 0){
    25.         return 0;
    26.     }
    27.     *value = q->data[q->front];
    28.     q->front++;
    29.     q->size--;
    30.  
    31.     // 初始化 如果是实时系统里面一直用队列，初始化非常的关键
    32.     if(q->size==0){
    33.         q->front    = 0;
    34.         q->rear     = -1;
    35.     }
    36.  
    37.     return 1;
    38. }
    39.  
    40. int is_queue_empty(queue *q){
    41.     return (q->size==0);
    42. }

    此部分内容，用于支撑博客DSP_TMS320F28335_优秀的串口通信框架_28335串口发送多个数据-CSDN博客的小队列通信方法。具体怎么应用上述的“以数组为底层的队列”，也可以通过看这篇博客去感受。

    2 栈

    stack.h 

    1. #ifndef USERPROGRAM_STACK_STACK_H_
    2. #define USERPROGRAM_STACK_STACK_H_
    3.  
    4. #include 
    5.  
    6.  
    7. #define STACK_MAX_SIZE 500
    8.  
    9. typedef struct _stack
    10. {
    11.     float data[STACK_MAX_SIZE]; //数组建立顺序栈
    12.     int top;//栈中元素个数
    13. }stack;
    14.  
    15. extern stack input_compute_stack;
    16. extern stack output_compute_stack;
    17.  
    18. void    stack_init(stack* s);
    19. int     is_stack_empty(stack* s);
    20. int     enstack(stack* s, float value);
    21. int     destack(stack* s, float * value);
    22. void    clearstack(stack* s);
    23.  
    24. float   computeformula(stack *s, float* constant_value, float* ch_value, Uint16* compute_rule, int N, int * ret);
    25.  
    26. #pragma CODE_SECTION(computeformula,"ramfuncs");
    27.  
    28. #endif /* USERPROGRAM_STACK_STACK_H_ */

    stack.c 

    1. #include 
    2.  
    3. stack input_compute_stack;
    4. stack output_compute_stack;
    5.  
    6. void stack_init(stack* s){
    7.     s->top = 0;
    8. }
    9.  
    10. int is_stack_empty(stack* s){
    11.     return (s->top==0);
    12. }
    13.  
    14. int enstack(stack* s, float value){
    15.     if (s->top == STACK_MAX_SIZE)
    16.     {
    17.         return 0;
    18.     }
    19.     else
    20.     {
    21.         s->data[s->top] = value;
    22.         s->top++;
    23.         return 1;
    24.     }
    25. }
    26.  
    27. int destack(stack* s, float * value)
    28. {
    29.     if (s->top == 0)
    30.     {
    31.         return 0;
    32.     }
    33.     else
    34.     {
    35.         s->top--;
    36.         *value = s->data[s->top];
    37.         return 1;
    38.     }
    39. }
    40.  
    41. void clearstack(stack* s){
    42.     s->top = 0;
    43. }

    下面备份一个栈的应用，用于后缀表达式，计算四则运算公式

    1. float computeformula(stack *s, float* constant_value, float* ch_value, Uint16* compute_rule, int N, int * ret){
    2.     int i;
    3.     float result = 0;
    4.     float operator1 = 0;
    5.     float operator2 = 0;
    6.     int stack_pop_ret1 = 1;
    7.     int stack_pop_ret2 = 1;
    8.     int stack_push_ret = 1;
    9.  
    10.     for(i = 0; i < N; i++){
    11.         switch (compute_rule[i]){
    12.             case ADD:
    13.                 stack_pop_ret1  = destack(s, &operator1);
    14.                 stack_pop_ret2  = destack(s, &operator2);
    15.                 result          = operator2 + operator1;
    16.                 stack_push_ret  = enstack(s, result);
    17.                 if(stack_pop_ret1==0 || stack_pop_ret2==0 || stack_push_ret==0){
    18.                     *ret = 0;
    19.                     clearstack(s);
    20.                     return 0;
    21.                 }
    22.                 break;
    23.             case SUBSTRACT:
    24.                 stack_pop_ret1  = destack(s, &operator1);
    25.                 stack_pop_ret2  = destack(s, &operator2);
    26.                 result          = operator2 - operator1;
    27.                 stack_push_ret  = enstack(s, result);
    28.                 if(stack_pop_ret1==0 || stack_pop_ret2==0 || stack_push_ret==0){
    29.                     *ret = 0;
    30.                     clearstack(s);
    31.                     return 0;
    32.                 }
    33.                 break;
    34.             case MULTIPLY:
    35.                 stack_pop_ret1  = destack(s, &operator1);
    36.                 stack_pop_ret2  = destack(s, &operator2);
    37.                 result          = operator2 * operator1;
    38.                 stack_push_ret  = enstack(s, result);
    39.                 if(stack_pop_ret1==0 || stack_pop_ret2==0 || stack_push_ret==0){
    40.                     *ret = 0;
    41.                     clearstack(s);
    42.                     return 0;
    43.                 }
    44.                 break;
    45.             case DIVIDE:
    46.                 stack_pop_ret1  = destack(s, &operator1);
    47.                 stack_pop_ret2  = destack(s, &operator2);
    48.                 if(stack_pop_ret1==0 || stack_pop_ret2==0 || operator1 == 0){
    49.                     *ret = 0;
    50.                     clearstack(s);
    51.                     return 0;
    52.                 }else{
    53.                     result          = operator2 / operator1;
    54.                     stack_push_ret  = enstack(s, result);
    55.                     if(stack_push_ret==0){
    56.                         *ret = 0;
    57.                         clearstack(s);
    58.                         return 0;
    59.                     }
    60.                 }
    61.                 break;
    62.             case CH1_P:
    63.                 stack_push_ret  = enstack(s, ch_value[0]);
    64.                 if(stack_push_ret==0){
    65.                     *ret = 0;
    66.                     clearstack(s);
    67.                     return 0;
    68.                 }
    69.                 break;
    70.             case CH2_P:
    71.                 stack_push_ret  = enstack(s, ch_value[1]);
    72.                 if(stack_push_ret==0){
    73.                     *ret = 0;
    74.                     clearstack(s);
    75.                     return 0;
    76.                 }
    77.                 break;
    78.             case CH3_P:
    79.                 stack_push_ret  = enstack(s, ch_value[2]);
    80.                 if(stack_push_ret==0){
    81.                     *ret = 0;
    82.                     clearstack(s);
    83.                     return 0;
    84.                 }
    85.                 break;
    86.             case CH4_P:
    87.                 stack_push_ret  = enstack(s, ch_value[3]);
    88.                 if(stack_push_ret==0){
    89.                     *ret = 0;
    90.                     clearstack(s);
    91.                     return 0;
    92.                 }
    93.                 break;
    94.             case CH5_P:
    95.                 stack_push_ret  = enstack(s, ch_value[4]);
    96.                 if(stack_push_ret==0){
    97.                     *ret = 0;
    98.                     clearstack(s);
    99.                     return 0;
    100.                 }
    101.                 break;
    102.             case CH1_N:
    103.                 stack_push_ret  = enstack(s, -ch_value[0]);
    104.                 if(stack_push_ret==0){
    105.                     *ret = 0;
    106.                     clearstack(s);
    107.                     return 0;
    108.                 }
    109.                 break;
    110.             case CH2_N:
    111.                 stack_push_ret  = enstack(s, -ch_value[1]);
    112.                 if(stack_push_ret==0){
    113.                     *ret = 0;
    114.                     clearstack(s);
    115.                     return 0;
    116.                 }
    117.                 break;
    118.             case CH3_N:
    119.                 stack_push_ret  = enstack(s, -ch_value[2]);
    120.                 if(stack_push_ret==0){
    121.                     *ret = 0;
    122.                     clearstack(s);
    123.                     return 0;
    124.                 }
    125.                 break;
    126.             case CH4_N:
    127.                 stack_push_ret  = enstack(s, -ch_value[3]);
    128.                 if(stack_push_ret==0){
    129.                     *ret = 0;
    130.                     clearstack(s);
    131.                     return 0;
    132.                 }
    133.                 break;
    134.             case CH5_N:
    135.                 stack_push_ret  = enstack(s, -ch_value[4]);
    136.                 if(stack_push_ret==0){
    137.                     *ret = 0;
    138.                     clearstack(s);
    139.                     return 0;
    140.                 }
    141.                 break;
    142.             case CONSTANT1:
    143.                 stack_push_ret  = enstack(s, constant_value[0]);
    144.                 if(stack_push_ret==0){
    145.                     *ret = 0;
    146.                     clearstack(s);
    147.                     return 0;
    148.                 }
    149.                 break;
    150.             case CONSTANT2:
    151.                 stack_push_ret  = enstack(s, constant_value[1]);
    152.                 if(stack_push_ret==0){
    153.                     *ret = 0;
    154.                     clearstack(s);
    155.                     return 0;
    156.                 }
    157.                 break;
    158.             case CONSTANT3:
    159.                 stack_push_ret  = enstack(s, constant_value[2]);
    160.                 if(stack_push_ret==0){
    161.                     *ret = 0;
    162.                     clearstack(s);
    163.                     return 0;
    164.                 }
    165.                 break;
    166.             case CONSTANT4:
    167.                 stack_push_ret  = enstack(s, constant_value[3]);
    168.                 if(stack_push_ret==0){
    169.                     *ret = 0;
    170.                     clearstack(s);
    171.                     return 0;
    172.                 }
    173.                 break;
    174.             case CONSTANT5:
    175.                 stack_push_ret  = enstack(s, constant_value[4]);
    176.                 if(stack_push_ret==0){
    177.                     *ret = 0;
    178.                     clearstack(s);
    179.                     return 0;
    180.                 }
    181.                 break;
    182.             default:
    183.                 break;
    184.         }
    185.     }
    186.  
    187.     clearstack(s);
    188.     *ret = 1;
    189.     return result;
    190.  
    191. }
    192.

    最后愿我们共同进步！ 感谢您的阅读，欢迎留言讨论、收藏、点赞、分享。 

  • 相关阅读:
    easyexcel升级3.3.4失败的经历
    第十三天到达终点数字
    JavaScript的综合案例
    C#界面里的AllowDrop属性、DragDrop和DragEnter事件
    微前端学习
    Reactive响应式WebClient负载调用微服务接口封装，自行编写类OpenFeign的Reactive实现
    加密的重要性，MySQL加密有哪些好处?
    P18 JMenuBar菜单栏
    发布自己的npm包注意事项
    Android Studio下运行java main 方法
  • 原文地址：https://blog.csdn.net/heqiunong/article/details/134260764