魔王语言解释——实现栈和队列顺序存储空间共享（选作内容）

---

问题描述

该实践设计题出自《数据结构——C语言版》

选作内容

即实现栈和队列的顺序存储空间共享，并且可以录入第一种规则，而非程序内固定。

概要设计与使用手册

用户执行程序后，先输入需要录入的规则数，随后按规定格式输入正确的规则，最后输入待翻译的魔王语言等待程序输出。

代码展示

代码中并没有使用结构体从而实现存储空间共享。
首先建立两个头文件language.h和S_Q_operation.h

language.h ：

#pragma once

#define MAX_RULE_LENGTH 100
#define MAX_INPUT_LENGTH 1000
#define MAX_OUTPUT_LENGTH 1000

void devil_language_init(int rules_cnt);

void get_rules();

void interpret(char* source, char* dest);

void traslate(char* original);

void devil_language_close();

S_Q_operation.h ：

#pragma once

#include<stdbool.h>

typedef char Item;

typedef Item* Queue;

typedef Item* Stack;

// Queue operation
Item Dequeue(Queue* pqueue);

// Stack operations
bool StackIsEmpty(const Stack* pstack);

Item Pop(Stack* pstack);

void Push(Stack* pstack, Item item);

对头文件进行编写
language.c ：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<ctype.h>

#include"language.h"
#include"S_Q_operation.h"

static int rules_count;
static char* keys;
static char** values;

void devil_language_init(int rules_number)
{
	rules_count = rules_number;
	assert(keys = malloc(sizeof(char) * rules_number + 1));
	assert(values = malloc(sizeof(char*) * rules_number + 1));
}

void get_rules()
{
	puts("\nPlease enter each rule in the format given below：");
	puts("(A->aBc...)");
	for (int i = 0; i < rules_count; i++)
	{
		values[i] = malloc(sizeof(char) * MAX_RULE_LENGTH);
		scanf_s("%c->%s", keys + i, 1, values[i], MAX_RULE_LENGTH);
		while (getchar() != '\n');
	}
	keys[rules_count] = '\0';
}

// 第二形式规则
static void unfold(char* queue, int size, char** pstack)
{
	int len = size * 2 - 1;
	char* buf;
	assert(buf = malloc(sizeof(char) * len));
	*buf = Dequeue(&queue);
	for (int i = 1; i < size; i++)
	{
		buf[i * 2 - 1] = Dequeue(&queue);
		buf[i * 2] = *buf;
	}
	for (int i = 0; i < len; i++)
	{
		Push(pstack, buf[i]);
	}
	free(buf);
}

void interpret(char* source, char* dest)
{
	int len = strlen(source);
	char tmp[MAX_OUTPUT_LENGTH];
	Stack stack = tmp + MAX_OUTPUT_LENGTH - len - 1;
	strcpy_s(stack, len + 1, source);
	while (!StackIsEmpty(&stack))
	{
		char ch = Pop(&stack);
		if (isupper(ch))
		{
			char* value = values[strchr(keys, ch) - keys];
			int cnt = 0;
			while (value[cnt]) cnt++;
			while (--cnt >= 0) Push(&stack, value[cnt]);
		}
		else if (ch == '(')
		{
			Queue queue = stack;
			int size = 0;
			while ((ch = Pop(&stack)) != ')') size++;
			unfold(queue, size, &stack);
		}
		else
		{
			*dest = ch;
			dest++;
		}
	}
	*dest = '\0';
}

void traslate(char* original)//对小写字母的翻译，对应翻译可根据自身喜好更改
{
	char ch;
	while (ch = *original)
	{
		switch (ch)
		{
		case 'a':
			printf("%s", "阿");
			break;
		case 'b':
			printf("%s", "备");
			break;
		case 'c':
			printf("%s", "差");
			break;
		case 'd':
			printf("%s", "弟");
			break;
		case 'e':
			printf("%s", "饿");
			break;
		case 'f':
			printf("%s", "放");
			break;
		case 'g':
			printf("%s", "过");
			break;
		case 'h':
			printf("%s", "好");
			break;
		case 'i':
			printf("%s", "爱");
			break;
		case 'j':
			printf("%s", "假");
			break;
		case 'k':
			printf("%s", "康");
			break;
		case 'l':
			printf("%s", "邋");
			break;
		case 'm':
			printf("%s", "妹");
			break;
		case 'n':
			printf("%s", "难");
			break;
		case 'o':
			printf("%s", "呕");
			break;
		case 'p':
			printf("%s", "Pi");
			break;
		case 'q':
			printf("%s", "期");
			break;
		case 'r':
			printf("%s", "人");
			break;
		case 's':
			printf("%s", "是");
			break;
		case 't':
			printf("%s", "遢");
			break;
		case 'u':
			printf("%s", "你");
			break;
		case 'v':
			printf("%s", "稳");
			break;
		case 'w':
			printf("%s", "我");
			break;
		case 'x':
			printf("%s", "小");
			break;
		case 'y':
			printf("%s", "瑶");
			break;
		case 'z':
			printf("%s", "准");
			break;
		default:
			break;
		}
		original++;
	}
	putchar('\n');
}

void devil_language_close()
{
	for (int i = 0; i < rules_count; i++) free(values[i]);
	free(values);
	free(keys);
}

S_Q_operation.c ：

#include<assert.h>
#include"S_Q_operation.h"

// Queue operation
Item Dequeue(Queue* pqueue)
{
	Item item = **pqueue;
	*pqueue += 1;
	return item;
}

// Stack operations
bool StackIsEmpty(const Stack* pstack)
{
	return **pstack == '\0';
}

Item Pop(Stack* pstack)
{
	assert(StackIsEmpty);
	Item item = **pstack;
	*pstack += 1;
	return item;
}

void Push(Stack* pstack, Item item)
{
	*pstack -= 1;
	**pstack = item;
}

main.c：

#include<stdio.h>

#include"language.h"


int main(void)
{
	char source[MAX_INPUT_LENGTH];
	char dest[MAX_OUTPUT_LENGTH];
	int rules_cnt;

	puts("Please enter the number of translation rules：");
	scanf_s("%d", &rules_cnt);
	while (getchar() != '\n');

	devil_language_init(rules_cnt);
	get_rules();

	puts("\nPlease input the magic language to be translated：");
	scanf_s("%s", source, MAX_INPUT_LENGTH);

	interpret(source, dest);
	puts("\nWords after translation：");
	puts(dest);

	puts("\n中文映射：");
	traslate(dest);

	devil_language_close();

	return 0;
}

运行结果