.实现推步聚顶术算法。**所需完成内容如下：**```c文档部分：1.给出伪代码描述算法。2.分析2个算法的渐进时间复杂度以及空间复杂度。3.C语言代码实现割补术及推步聚顶术算法。录屏部分：录屏讲解文

伪代码描述算法：
1. 初始化一个堆栈，用于存储割补术和推步聚顶术的操作。
2. 读取输入的表达式字符串。
3. 从左到右遍历表达式字符串，对于每个字符：
a. 如果是操作数，将其压入堆栈。
b. 如果是运算符，弹出堆栈顶部的两个元素，进行相应的运算，然后将结果压回堆栈。
4. 当遍历完表达式字符串后，堆栈中只剩下一个元素，即为表达式的结果。

渐进时间复杂度分析：
割补术和推步聚顶术算法的时间复杂度均为O(n)，其中n为表达式字符串的长度。这是因为算法需要遍历整个表达式字符串，对于每个字符进行相应的操作。

空间复杂度分析：
割补术和推步聚顶术算法的空间复杂度均为O(n)，其中n为表达式字符串的长度。这是因为算法需要使用堆栈来存储中间结果，最坏情况下，堆栈的大小可能与表达式字符串的长度相等。

C语言代码实现割补术及推步聚顶术算法：

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
int *data;
int top;
int size;
} Stack;

void push(Stack *stack, int value) {
if (stack->top == stack->size - 1) {
printf("Stack overflow
");
exit(1);
}
stack->data[++(stack->top)] = value;
}

int pop(Stack *stack) {
if (stack->top == -1) {
printf("Stack underflow
");
exit(1);
}
return stack->data[(stack->top)--];
}

int peek(Stack *stack) {
if (stack->top == -1) {
printf("Stack is empty
");
exit(1);
}
return stack->data[stack->top];
}

int is_empty(Stack *stack) {
return stack->top == -1;
}

void init_stack(Stack *stack, int size) {
stack->data = (int *)malloc(size * sizeof(int));
stack->top = -1;
stack->size = size;
}

void free_stack(Stack *stack) {
free(stack->data);
}

int calculate(int a, int b, char op) {
switch (op) {
case '+':
return a + b;
case '-':
return a - b;
case '*':
return a * b;
case '/':
return a / b;
default:
printf("Invalid operator: %c
", op);
exit(1);
}
}

int evaluate_expression(char *expression) {
Stack stack;
init_stack(&stack, strlen(expression));

for (int i = 0; i < strlen(expression); i++) {
char ch = expression[i];
if (isdigit(ch)) {
push(&stack, ch - '0');
} else {
int b = pop(&stack);
int a = pop(&stack);
int result = calculate(a, b, ch);
push(&stack, result);
}
}

int result = pop(&stack);
free_stack(&stack);
return result;
}

int main() {
char expression[] = "3+2*6-4/2";
int result = evaluate_expression(expression);
printf("Result: %d
", result);
return 0;
}
```