1、一个栈的输入序列为：a，b，c，d，e，则栈的不可能输出的序列是（ ）。 A. a,b,c,d,e B. d,e,c,b,a C. d,c,e,a,b D. e,d,c,b,a

栈的输入序列为 a，b，c，d，e，则栈的不可能输出的序列是 d，c，e，a，b。因为在输入序列中，a 在最底下，e 在最上面，所以 e 一定在栈顶，a 一定在栈底。而 d 和 c 在 a 的上面，所以 d 和 c 必然先于 a 出栈，而 e 在最后出栈，所以 d，c，e 的顺序是不可能的。因此，选C。

相关问题

键盘输入一个十进制数，输出对应的二级制数。如：65à1000001B （要求采用顺序栈或链栈实现，或者分别实现。）

### 回答1：
好的，这是一个经典的编程类问题。以下是我给出的代码，使用顺序栈实现：

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

#define STACK_INIT_SIZE 100
#define STACK_INCREMENT 10

typedef struct {
    int *top;
    int *base;
    int stack_size;
} SqStack;

void InitStack(SqStack *S) {
    S->base = (int *)malloc(STACK_INIT_SIZE * sizeof(int));
    if (!S->base) {
        exit(1);
    }
    S->top = S->base;
    S->stack_size = STACK_INIT_SIZE;
}

void Push(SqStack *S, int e) {
    if (S->top - S->base == S->stack_size) {
        S->base = (int *)realloc(S->base, (S->stack_size + STACK_INCREMENT) * sizeof(int));
        if (!S->base) {
            exit(1);
        }
        S->top = S->base + S->stack_size;
        S->stack_size += STACK_INCREMENT;
    }
    *(S->top) = e;
    S->top++;
}

void Pop(SqStack *S, int *e) {
    if (S->top == S->base) {
        exit(1);
    }
    S->top--;
    *e = *(S->top);
}

int StackLen(SqStack S) {
    return S.top - S.base;
}

int main() {
    SqStack S;
    InitStack(&S);
    int n;
    printf("请输入一个十进制数：");
    scanf("%d", &n);
    while (n) {
        Push(&S, n % 2);
        n /= 2;
    }
    printf("对应的二进制数为：");
    while (StackLen(S)) {
        int e;
        Pop(&S, &e);
        printf("%d", e);
    }
    printf("\n");
    return 0;
}

如果您需要使用链栈实现，可以自己尝试编写。

### 回答2：
键盘输入一个十进制数，首先我们需要将输入的十进制数转换为二进制数。转换过程可以使用顺序栈或链栈实现。

假设输入的十进制数为n，我们可以通过除2取余的方法，将十进制数n转换为二进制数。

具体的转换方法如下：
1. 创建一个栈，用来存放二进制数的每一位。
2. 将n与2进行除法运算，并将余数压入栈中。
3. 将n除以2的商作为新的n的值，并继续执行步骤2，直到商等于0为止。
4. 将栈中的元素依次弹出，得到的序列即为二进制数的逆序。
5. 将逆序的二进制数转换为正序，并输出。

以下是使用顺序栈实现的代码示例：

class Stack(object):
    def __init__(self):
        self.stack = []

    def is_empty(self):
        return len(self.stack) == 0
    
    def push(self, value):
        self.stack.append(value)
        
    def pop(self):
        if self.is_empty():
            return None
        return self.stack.pop()
        
def decimal_to_binary(decimal):
    stack = Stack()
    
    while decimal > 0:
        remainder = decimal % 2
        stack.push(remainder)
        decimal = decimal // 2
        
    binary = ""
    while not stack.is_empty():
        binary += str(stack.pop())
        
    return binary

# 测试
decimal_num = int(input("请输入一个十进制数："))
binary_num = decimal_to_binary(decimal_num)
print("对应的二进制数为：", binary_num, "B")

使用该代码，可以根据用户输入的十进制数，输出对应的二进制数。例如，输入65，输出1000001B

### 回答3：
要实现键盘输入一个十进制数，输出对应的二进制数，可以使用顺序栈或链栈来实现。

1. 使用顺序栈实现：

（1）创建一个空栈来保存二进制数的各个位。

（2）将输入的十进制数除以2，得到的余数依次入栈，直到商为0为止。

（3）将栈中的元素逐个出栈，得到的即为该十进制数对应的二进制数。

以下是一个用顺序栈实现的伪代码示例：

stack = create_stack()  // 创建一个空栈

num = input("请输入一个十进制数：")  // 从键盘输入一个十进制数

while num > 0:
    remainder = num % 2  // 得到余数
    push(stack, remainder)  // 将余数入栈
    num = num // 2  // 更新商

binary = ""  // 保存二进制数的字符串

while not is_empty(stack):
    digit = pop(stack)  // 从栈中取出一个位的数值
    binary = binary + str(digit)  // 将数值转换为字符串，拼接到二进制数的字符串上

print("对应的二进制数为：" + binary)

2. 使用链栈实现：

链栈是一种基于链表的栈结构，可以按照类似于顺序栈的方法来实现。

具体步骤和顺序栈实现类似，只是在链栈中，每个节点除了存储数值外，还存储指向下一个节点的指针。

以上是使用顺序栈和链栈来实现键盘输入一个十进制数，输出对应的二进制数的介绍，希望对您有所帮助。

输入字符序列，建立并输出一棵二叉树，分别按先序，中序，后序遍历输出二叉树

这里提供一个基于Python语言的实现方法：

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

class BinaryTree:
    def __init__(self):
        self.root = None

    def build_tree(self, s):
        stack = []
        i = 0
        while i < len(s):
            if s[i] == '#':
                node = None
                if len(stack) > 0:
                    node = stack.pop()
                if len(stack) > 0:
                    parent = stack[-1]
                    if parent.left is None:
                        parent.left = node
                    else:
                        parent.right = node
                else:
                    self.root = node
            else:
                node = TreeNode(s[i])
                stack.append(node)
            i += 1

    def preorder_traversal(self, root):
        if root is None:
            return
        print(root.val, end=' ')
        self.preorder_traversal(root.left)
        self.preorder_traversal(root.right)

    def inorder_traversal(self, root):
        if root is None:
            return
        self.inorder_traversal(root.left)
        print(root.val, end=' ')
        self.inorder_traversal(root.right)

    def postorder_traversal(self, root):
        if root is None:
            return
        self.postorder_traversal(root.left)
        self.postorder_traversal(root.right)
        print(root.val, end=' ')

# 测试代码
if __name__ == '__main__':
    s = 'ABD##E##CF##G##'
    tree = BinaryTree()
    tree.build_tree(s)

    print('先序遍历：', end='')
    tree.preorder_traversal(tree.root)
    print()

    print('中序遍历：', end='')
    tree.inorder_traversal(tree.root)
    print()

    print('后序遍历：', end='')
    tree.postorder_traversal(tree.root)
    print()

输入序列为一个字符串，其中每个节点用一个字母表示，空节点用字符'#'表示。例如，输入字符串'ABD##E##CF##G##'，表示的二叉树如下所示：

     A
    / \
   B   C
  /   / \
 D   F   G
  \      
   E     

输出先序遍历、中序遍历、后序遍历的结果分别为：

先序遍历：A B D E C F G 
中序遍历：D B E A F C G 
后序遍历：D E B F G C A 

这里采用了栈的数据结构来辅助建立二叉树，并实现了三种遍历方式的递归算法。