有大神帮忙看一下这个代码存在什么问题吗？万分感谢！

一个数据结构的问题，在主函数中的‘B’情况运行到EnQueue(Q1,e)的时候出现异常。
using namespace std;
#include
#include
#include
#include

typedef int Status;

#define int Status
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define MAXSIZE 100

//链栈
typedef struct StackNode {
char data;
struct StackNode *next;
}StackNode, *LinkStackPtr;
typedef struct LinkStack {
LinkStackPtr top;
int size;
}LinkStack;

//重要操作 LinkStack
//判断是否为空栈
Status StackEmpty(LinkStack *S) {
if (S->size == 0) {
return TRUE;
}
else {
return FALSE;
}
}
//初始化一个栈
Status InitStack(LinkStack *S) {
S->top = NULL;
S->size = 0;
return OK;
}
//返回栈顶元素
Status GetTop(LinkStack *S, char * e) {//char
if (S->size == 0) {
return ERROR;
}
else {
*e = S->top->data;
}
return OK;
}
//进栈操作
Status push(LinkStack *S, char e) {
LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StackNode));
s->data = e;
s->next = S->top;
S->top = s;
S->size++;
return OK;
}
//出栈操作
Status pop(LinkStack *S, char *e) {
if (StackEmpty(S)) {
return FALSE;
}
else {
*e = S->top->data;
LinkStackPtr s = S->top;
S->top = s->next;
S->size--;
free(s);
return OK;
}
}

//链队列
typedef struct QNode {
char data;
struct QNode *next;
}QNode, *QueuePtr;//结点结构
typedef struct {
QueuePtr front, rear;
int Size;
}LinkQueue;//队列的链表结构

//重要操作 LinkQueue
//判断是否为空队列
Status QueueEmpty(LinkQueue *Q) {
if (Q->Size == 0) {
return TRUE;
}
else {
return FALSE;
}
}
//初始化
Status InitQueue(LinkQueue *Q) {
Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));
if (!Q->front) exit(OVERFLOW);
Q->front->next = NULL;
Q->Size = 0;
return OK;
}
//入队列
Status EnQueue(LinkQueue *Q, char e) {//链队列是带头节点的，头指针永远指向头节点
QueuePtr q = (QueuePtr)malloc(sizeof(QNode));
if (!q) exit(OVERFLOW);
q->data = e;
q->next = NULL;
Q->rear->next = q;
Q->rear = q;
Q->Size++;
return OK;
}
//出队列
Status DeQueue(LinkQueue *Q, char *e) {
if (Q->front == Q->rear) return ERROR;
*e = Q->front->data;
QueuePtr q = Q->front->next;
Q->front->next = q->next;
if (q == Q->rear) Q->rear = Q->front;
Q->Size--;
free(q);
return OK;
}

//talk函数用于将魔王的语言进行压栈
Status Language_Talk(LinkStack *S) {
char word[MAXSIZE];
cout << "请输入魔王的语言";
cin >> word;
int i;
int j = 0;
int left = 0, right = 0;
cout << "魔王语言为"<<word << endl;
int len = strlen(word) - 1;
cout <<"魔王语言长度为"<< len+1 << endl;

cout << "成功输入魔王语言";

while (j<len) {

    if (word[j] == '(')
        left++;
    if (word[j] == ')')
        right++;
    j++;
}

if (len+1==0) {
    cout << "魔王没有说话";
    return ERROR;
}
else {
    if (left != right) {
        cout << "魔王说了错误的话";
        return ERROR;
    }
    else {
        for (i = len;i >= 0;i--) {
            push(S, word[i]);
        }
        }
    }
return OK;
}

//已经解析的语言存入数组
Status Language_Record(LinkQueue *Q, LinkQueue *Q1) {
//char *e=;
char *e = (char *)malloc(sizeof(char));
while (!QueueEmpty(Q)) {
DeQueue(Q, e);
EnQueue(Q1, *e);
}
return OK;
}

//词汇依次出栈进行处理
//A情况
char Language_explanA(LinkStack S, LinkQueue *Q) {
//char *e;
char *e = (char *)malloc(sizeof(char));
pop(S, e);
char E = *e;
free(e);
int a = 0;
char A[10] = "sae";
while (a <= 2) {
EnQueue(Q, A[a]);
a++;
}
return *e;
/*cout << A;
cout << "输出第一个元素";
cout << Q->front->data;/
//return OK;
}
//B情况
Status Language_explanB(LinkStack S, LinkQueue *Q) {
//char *e;
char *e = (char)malloc(sizeof(char));
pop(S, e);
int b = 0;
char B[10] = "tsaedsae";
while (B[b]) {
EnQueue(Q, B[b]);
b++;
}
return 0;
}
//‘（’情况
Status Language_explanleft(LinkStack S, LinkQueue *Q) {
//char *e;
char *e = (char)malloc(sizeof(char));
pop(S, e);
pop(S, e);
char sita = e;
EnQueue(Q, sita);
while (S->top->data != ')') {
pop(S, e);
EnQueue(Q, *e);
EnQueue(Q, sita);
}
return 0;
}
//'）'情况
Status Language_explanright(LinkStack *S, LinkQueue *Q) {
//char *e;
char *e = (char)malloc(sizeof(char));
pop(S, e);
while (!QueueEmpty) {
DeQueue(Q, e);
push(S, *e);
}
return OK;
}

int main() {
int position = 0;
LinkStack *Link_Stack = (LinkStack *)malloc(sizeof(StackNode));
LinkQueue *Link_Queue = (LinkQueue *)malloc(sizeof(QNode));
LinkQueue *Humanwords = (LinkQueue *)malloc(sizeof(QNode));
InitStack(Link_Stack);
InitQueue(Link_Queue);
char Devilwords[MAXSIZE];

Language_Talk(Link_Stack);
cout << Link_Stack->size;
cout << Link_Stack->top->data << endl;

while (!StackEmpty(Link_Stack)) {
    if (Link_Stack->top->data == 'A') {
        Language_explanA(Link_Stack, Link_Queue);
        cout << "执行了A";
        cout << Link_Queue->Size << endl;
        cout << Link_Stack->size << endl;
    }
    if (Link_Stack->top->data == 'B') {
        Language_explanB(Link_Stack, Link_Queue);
        cout << Link_Queue->Size << endl;
        cout << Link_Stack->size << endl;
    }
    if (Link_Stack->top->data == '(') {
        Language_Record(Link_Queue, Humanwords);
        Language_explanleft(Link_Stack, Link_Queue);
    }
    if (Link_Stack->top->data == ')')
        Language_explanright(Link_Stack, Link_Queue);
}
cout << Humanwords;
system("pause");
return OK;

}

编译错误信息是什么呀？（我要完整的）

错误信息是什么，真的应该说一下。。。赋值的代码到编译器错误太多了。。。

http://blog.chinaunix.net/uid-24399976-id-363721.html 直接去看这个代码吧。。。

哈哈，魔王的语言。整体来说错误不多。大多是编译错误，函数传的类型不对。
在主函数中循环读取栈中数据，检查完之后要出栈。
你的代码没有经过编译。敲下来错误这么少，说明代码还可以。能运行的。
代码的对齐要注意。if 的 body 中要用 {} 括上，避免出现笔误。

整理之后代码如下：

 #include <stdio.h>
#include <iostream>
#include <malloc.h>
#include <stdlib.h>
typedef int Status;
#define int Status
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define MAXSIZE 100
using namespace std;
//链栈
typedef struct StackNode
{
    char data;
    struct StackNode *next;
}StackNode, *LinkStackPtr;

typedef struct LinkStack
{
    LinkStackPtr top;
    int size;
}LinkStack;

//重要操作 LinkStack
//判断是否为空栈
Status StackEmpty(LinkStack *S)
{
    if (S->size == 0)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}
//初始化一个栈
Status InitStack(LinkStack *S)
{
    S->top = NULL;
    S->size = 0;
    return OK;
}
//返回栈顶元素
Status GetTop(LinkStack *S, char * e)
{//char
    if (S->size == 0)
    {
        return ERROR;
    }
    else
    {
        *e = S->top->data;
    }
    return OK;
}
//进栈操作
Status push(LinkStack *S, char e)
{
    LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StackNode));
    s->data = e;
    s->next = S->top;
    S->top = s;
    S->size++;
    return OK;
}
//出栈操作
Status pop(LinkStack *S, char *e)
{
    if (StackEmpty(S))
    {
        return FALSE;
    }
    else
    {
        *e = S->top->data;
        LinkStackPtr s = S->top;
        S->top = s->next;
        S->size--;
        free(s);
        return OK;
    }
}
//链队列
typedef struct QNode
{
    char data;
    struct QNode *next;
}QNode, *QueuePtr;//结点结构

typedef struct
{
    QueuePtr front, rear;
    int Size;
}LinkQueue;//队列的链表结构

//重要操作 LinkQueue
//判断是否为空队列
Status QueueEmpty(LinkQueue *Q)
{
    if (Q->Size == 0)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}
//初始化
Status InitQueue(LinkQueue *Q)
{
    Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode));

    if (!Q->front) exit(OVERFLOW);

    Q->front->next = NULL;
    Q->Size = 0;
    return OK;
}

//入队列
Status EnQueue(LinkQueue *Q, char e)
{//链队列是带头节点的，头指针永远指向头节点
    QueuePtr q = (QueuePtr)malloc(sizeof(QNode));

    if (!q) exit(OVERFLOW);

    q->data = e;
    q->next = NULL;
    Q->rear->next = q;
    Q->rear = q;
    Q->Size++;
    return OK;
}
//出队列
Status DeQueue(LinkQueue *Q, char *e)
{
    if (Q->front == Q->rear) return ERROR;

    *e = Q->front->data;
    QueuePtr q = Q->front->next;
    Q->front->next = q->next;
    if (q == Q->rear) Q->rear = Q->front;

    Q->Size--;
    free(q);
    return OK;
}
//talk函数用于将魔王的语言进行压栈
Status Language_Talk(LinkStack *S)
{
    char word[MAXSIZE];
    cout << "请输入魔王的语言";
    cin >> word;
    int i;
    int j = 0;
    int left = 0, right = 0;
    cout << "魔王语言为" << word << endl;
    int len = strlen(word) - 1;
    cout << "魔王语言长度为" << len + 1 << endl;
    cout << "成功输入魔王语言";

    while (j < len) {

        if (word[j] == '(')
            left++;
        if (word[j] == ')')
            right++;
        j++;
    }

    if (len + 1 == 0)
    {
        cout << "魔王没有说话";
        return ERROR;
    }
    else
    {
        if (left != right)
        {
            cout << "魔王说了错误的话";
            return ERROR;
        }
        else
        {
            for (i = len; i >= 0; i--)
            {
                push(S, word[i]);
            }
        }
    }
    return OK;
}
//已经解析的语言存入数组
Status Language_Record(LinkQueue *Q, LinkQueue *Q1)
{
    //char *e=;
    char *e = (char *)malloc(sizeof(char));
    while (!QueueEmpty(Q))
    {
        DeQueue(Q, e);
        EnQueue(Q1, *e);
    }
    return OK;
}
//词汇依次出栈进行处理
//A情况
char Language_explanA(LinkStack* S, LinkQueue *Q)
{
    //char *e;
    char *e = (char *)malloc(sizeof(char));
    pop(S, e);
    char E = *e;
    free(e);
    int a = 0;
    char A[10] = "sae";
    while (a <= 2) {
        EnQueue(Q, A[a]);
        a++;
    }
    return *e;
    cout << A;
    cout << "输出第一个元素";
    cout << Q->front->data;
    //return OK;
}
//B情况
Status Language_explanB(LinkStack *S, LinkQueue *Q) {
    //char *e;
    char *e = (char*)malloc(sizeof(char));
    pop(S, e);
    int b = 0;
    char B[10] = "tsaedsae";
    while (B[b]) {
        EnQueue(Q, B[b]);
        b++;
    }
    return 0;
}
//‘（’情况
Status Language_explanleft(LinkStack *S, LinkQueue *Q) {
    //char *e;
    char *e = (char*)malloc(sizeof(char));
    pop(S, e);
    pop(S, e);
    char sita = *e;
    EnQueue(Q, sita);
    while (S->top->data != ')') {
        pop(S, e);
        EnQueue(Q, *e);
        EnQueue(Q, sita);
    }
    return 0;
}
//'）'情况
Status Language_explanright(LinkStack *S, LinkQueue *Q) {
    //char *e;
    char *e = (char*)malloc(sizeof(char));
    pop(S, e);
    while (!QueueEmpty(Q))
    {
        DeQueue(Q, e);
        push(S, *e);
    }
    return OK;
}

int main() 
{
    int position = 0;
    LinkStack *Link_Stack = (LinkStack *)malloc(sizeof(StackNode));
    LinkQueue *Link_Queue = (LinkQueue *)malloc(sizeof(QNode));
    LinkQueue *Humanwords = (LinkQueue *)malloc(sizeof(QNode));
    InitStack(Link_Stack);
    InitQueue(Link_Queue);
    char Devilwords[MAXSIZE];
    Language_Talk(Link_Stack);
    cout << Link_Stack->size;
    cout << Link_Stack->top->data << endl;

    while (!StackEmpty(Link_Stack)) 
    {
        if (Link_Stack->top->data == 'A') 
        {
            Language_explanA(Link_Stack, Link_Queue);
            cout << "执行了A";
            cout << Link_Queue->Size << endl;
            cout << Link_Stack->size << endl;
        }
        if (Link_Stack->top->data == 'B') 
        {
            Language_explanB(Link_Stack, Link_Queue);
            cout << Link_Queue->Size << endl;
            cout << Link_Stack->size << endl;
        }
        if (Link_Stack->top->data == '(') 
        {
            Language_Record(Link_Queue, Humanwords);
            Language_explanleft(Link_Stack, Link_Queue);
        }
        if (Link_Stack->top->data == ')')
            Language_explanright(Link_Stack, Link_Queue);
        char c;
        pop(Link_Stack, &c);
    }
    cout << Humanwords;
    system("pause");
    return OK;
}