1)设计顺序栈的遍历接口： void TraverseStack(SqStack S); 实现栈中数据按出栈的顺序输出，但保留栈中的数据;\

要实现顺序栈的遍历接口，按照出栈的顺序输出，但是要保留栈中的数据，可以参考以下代码实现：

void TraverseStack(SqStack S) {
  // 判断栈是否为空
  if (S.top == -1) {
    printf("栈为空！");
    return;
  }
  
  // 创建一个临时栈
  SqStack tempStack;
  InitStack(&tempStack);
  
  // 将原栈中的元素依次出栈并压入临时栈
  while(!StackEmpty(&S)) {
    ElemType elem;
    Pop(&S, &elem);
    Push(&tempStack, elem);
  }
  
  // 将临时栈中的元素依次出栈并输出
 while(!StackEmpty(&tempStack)) {
    ElemType elem;
    Pop(&tempStack, &elem);
    printf("%d ", elem); // 输出元素
    Push(&S, elem); // 将元素重新压入原栈
  }
}

相关问题

c语言实现顺序栈的创建、入栈、出栈、取栈顶元素、遍历的完整代码

以下是C语言实现顺序栈的完整代码：

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

#define MAXSIZE 100 // 定义栈的最大容量

typedef int ElemType; // 栈元素类型

typedef struct {
    ElemType data[MAXSIZE]; // 存储栈元素
    int top; // 栈顶指针
} SqStack;

// 初始化栈
void InitStack(SqStack *s) {
    s->top = -1;
}

// 判断栈是否为空
int IsEmpty(SqStack s) {
    return s.top == -1;
}

// 判断栈是否已满
int IsFull(SqStack s) {
    return s.top == MAXSIZE - 1;
}

// 入栈
int Push(SqStack *s, ElemType e) {
    if (IsFull(*s)) // 栈已满，无法入栈
        return 0;
    s->data[++s->top] = e; // 栈顶指针加1，将元素e入栈
    return 1;
}

// 出栈
int Pop(SqStack *s, ElemType *e) {
    if (IsEmpty(*s)) // 栈为空，无法出栈
        return 0;
    *e = s->data[s->top--]; // 将栈顶元素赋值给e，栈顶指针减1
    return 1;
}

// 取栈顶元素
int GetTop(SqStack s, ElemType *e) {
    if (IsEmpty(s)) // 栈为空，无栈顶元素
        return 0;
    *e = s.data[s.top]; // 将栈顶元素赋值给e
    return 1;
}

// 遍历栈
void TraverseStack(SqStack s) {
    int i;
    printf("栈中元素为：");
    for (i = s.top; i >= 0; i--) // 从栈顶到栈底依次输出元素
        printf("%d ", s.data[i]);
    printf("\n");
}

int main() {
    SqStack s;
    ElemType e;
    int i;

    InitStack(&s); // 初始化栈
    printf("入栈操作：\n");
    printf("请输入要入栈的元素，以-1结束：");
    scanf("%d", &e);
    while (e != -1) {
        if (!Push(&s, e)) // 入栈失败
            printf("栈已满，%d未入栈！\n", e);
        else
            printf("%d已入栈\n", e);
        scanf("%d", &e);
    }

    printf("\n出栈操作：\n");
    while (!IsEmpty(s)) {
        if (!Pop(&s, &e)) // 出栈失败
            printf("栈已空，无法出栈！\n");
        else
            printf("%d已出栈\n", e);
    }

    printf("\n遍历栈操作：\n");
    for (i = 1; i <= 5; i++)
        Push(&s, i); // 入栈操作
    TraverseStack(s); // 遍历栈

    return 0;
}

以上代码实现了顺序栈的创建、入栈、出栈、取栈顶元素和遍历等基本操作。

链栈和顺序栈的创建，入栈，出栈，取栈顶元素，遍历，C语言，可进行输入

链栈和顺序栈是栈的两种实现方式，它们的基本操作包括创建、入栈、出栈、取栈顶元素和遍历。

1. 顺序栈

顺序栈是基于数组实现的栈，它的创建、入栈、出栈、取栈顶元素和遍历操作如下：

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

#define MAXSIZE 100 // 栈的最大容量

typedef struct {
  int data[MAXSIZE]; // 数据元素
  int top; // 栈顶指针
} SqStack;

// 初始化栈
void InitStack(SqStack *S) {
  S->top = -1;
}

// 判断栈是否为空
int IsEmpty(SqStack *S) {
  return (S->top == -1);
}

// 判断栈是否已满
int IsFull(SqStack *S) {
  return (S->top == MAXSIZE - 1);
}

// 入栈
int Push(SqStack *S, int x) {
  if (IsFull(S)) {
    return 0; // 栈已满，入栈失败
  } else {
    S->top++;
    S->data[S->top] = x;
    return 1; // 入栈成功
  }
}

// 出栈
int Pop(SqStack *S) {
  if (IsEmpty(S)) {
    return 0; // 栈已空，出栈失败
  } else {
    int x = S->data[S->top];
    S->top--;
    return x; // 返回出栈元素
  }
}

// 取栈顶元素
int GetTop(SqStack *S) {
  if (IsEmpty(S)) {
    return 0; // 栈已空，无栈顶元素
  } else {
    return S->data[S->top];
  }
}

// 遍历栈
void TraverseStack(SqStack *S) {
  if (IsEmpty(S)) {
    printf("Stack is empty.\n");
  } else {
    printf("Stack elements: ");
    for (int i = S->top; i >= 0; i--) {
      printf("%d ", S->data[i]);
    }
    printf("\n");
  }
}

int main() {
  SqStack S;
  InitStack(&S);
  int x;
  printf("Enter elements to push into stack (enter 0 to stop):\n");
  while (1) {
    scanf("%d", &x);
    if (x == 0) {
      break;
    }
    Push(&S, x);
  }
  TraverseStack(&S);
  printf("Pop elements from stack (enter 0 to stop):\n");
  while (1) {
    scanf("%d", &x);
    if (x == 0) {
      break;
    }
    if (Pop(&S)) {
      printf("Pop element: %d\n", x);
    } else {
      printf("Stack is empty.\n");
      break;
    }
  }
  printf("Top element of stack: %d\n", GetTop(&S));
  return 0;
}

2. 链栈

链栈是基于链表实现的栈，它的创建、入栈、出栈、取栈顶元素和遍历操作如下：

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

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

// 初始化栈
void InitStack(LinkStack *S) {
  *S = NULL;
}

// 判断栈是否为空
int IsEmpty(LinkStack S) {
  return (S == NULL);
}

// 入栈
void Push(LinkStack *S, int x) {
  LinkNode *p = (LinkNode *)malloc(sizeof(LinkNode));
  p->data = x;
  p->next = *S;
  *S = p;
}

// 出栈
int Pop(LinkStack *S) {
  if (IsEmpty(*S)) {
    return 0; // 栈已空，出栈失败
  } else {
    LinkNode *p = *S;
    int x = p->data;
    *S = p->next;
    free(p);
    return x; // 返回出栈元素
  }
}

// 取栈顶元素
int GetTop(LinkStack S) {
  if (IsEmpty(S)) {
    return 0; // 栈已空，无栈顶元素
  } else {
    return S->data;
  }
}

// 遍历栈
void TraverseStack(LinkStack S) {
  if (IsEmpty(S)) {
    printf("Stack is empty.\n");
  } else {
    printf("Stack elements: ");
    LinkNode *p = S;
    while (p) {
      printf("%d ", p->data);
      p = p->next;
    }
    printf("\n");
  }
}

int main() {
  LinkStack S;
  InitStack(&S);
  int x;
  printf("Enter elements to push into stack (enter 0 to stop):\n");
  while (1) {
    scanf("%d", &x);
    if (x == 0) {
      break;
    }
    Push(&S, x);
  }
  TraverseStack(S);
  printf("Pop elements from stack (enter 0 to stop):\n");
  while (1) {
    scanf("%d", &x);
    if (x == 0) {
      break;
    }
    if (Pop(&S)) {
      printf("Pop element: %d\n", x);
    } else {
      printf("Stack is empty.\n");
      break;
    }
  }
  printf("Top element of stack: %d\n", GetTop(S));
  return 0;
}