读进合法的BASIC程序并给语句重新编号，使得第一条语句从F处开始，并且每一个语句的序号比前面一语句高D。

数据结构与算法分析——c语言描述 练习5.12 答案

语句序号可以大到32比特的整树。程序必须以线性时间运行。

basic程序是这样的（出自维基）：

10 INPUT "What is your name: "; U$
20 PRINT "Hello "; U$
30 INPUT "How many stars do you want: "; N
40 S$ = ""
50 FOR I = 1 TO N
60 S$ = S$ + "*"
70 NEXT I
80 PRINT S$
90 INPUT "Do you want more stars? "; A$
100 IF LEN(A$) = 0 THEN GOTO 90
110 A$ = LEFT$(A$, 1)
120 IF A$ = "Y" OR A$ = "y" THEN GOTO 30
130 PRINT "Goodbye "; U$
140 END

大概就是用一个hash映射吧。把原来的语句顺序在O(1)复杂度内找到新的语句顺序。

输入上面的程序，然后在新的一行里按Ctrl+z结束输入。

hashQuad.h

typedef int XType;
typedef int YType;

#ifndef _HashQuad_H
#define _HashQuad_H

typedef unsigned int Index;
typedef Index Position;

struct HashTbl;
typedef struct HashTbl* HashTable;

HashTable initializeTable(int tableSize);
void destroyTable(HashTable h);
Position find(XType x, HashTable h);
HashTable insert(XType x,YType y, HashTable h);
HashTable rehash(HashTable h);
YType map(XType x , HashTable h);
int isLegitimate(Position pos, HashTable h);
#endif

hashQuad.cpp

#include"hashQuad.h"
#include"fatal.h"
#include<math.h>
#include<string.h>
#define MinTableSize 5

enum KindOfEntry { Legitimate, Empty, Deleted };

struct ElementType {
XType x;
YType y;
};

struct HashEntry {
ElementType element;
enum KindOfEntry info;
};

typedef struct HashEntry Cell;

struct HashTbl {
int tableSize;
int hasInsertedNum;
Cell *theCells;//数组
};

static int hash(XType x, int tableSize) {
return x % (tableSize);
}

static Position hash2(XType x, int tableSize) {
return 7 - (x % 7);
}

static int isPrime(int num) {
for (int i = 2; i <= sqrt(num); i++)
if (num%i == 0)
return 0;
return 1;
}
static int nextPrime(int num) {
int i = num;
while (!isPrime(i))
i++;
return i;
}

int isLegitimate(Position pos, HashTable h) {
return h->theCells[pos].info == Legitimate;
}

HashTable initializeTable(int tableSize) {
HashTable h;
int i;
if (tableSize < MinTableSize) {
Error("Table size too small");
return NULL;
}
h = (HashTable)malloc(sizeof(struct HashTbl));
if (h == NULL)
FatalError("Out of space!!!");
h->tableSize = nextPrime(tableSize);
h->theCells = (Cell*)malloc(sizeof(Cell)*h->tableSize);
h->hasInsertedNum = 0;
if (h->theCells == NULL)
FatalError("Out of space!!!");
for (i = 0; i < h->tableSize; i++) {
h->theCells[i].info = Empty;
}
return h;
}

void destroyTable(HashTable h) {
free(h->theCells);
free(h);
}

static Position find(XType x, HashTable h) {
Position currentPos = hash(x, h->tableSize);
int i = 0;
while (h->theCells[currentPos].info != Empty && h->theCells[currentPos].element.x != x) {
currentPos += (++i * hash2(x, h->tableSize));
currentPos = currentPos % h->tableSize;
}
return currentPos;
}

HashTable insert(XType x, YType y, HashTable h) {
if ((double)h->hasInsertedNum / h->tableSize > 0.5)
h = rehash(h);
Position pos = find(x, h);
if (h->theCells[pos].info != Legitimate) {
h->theCells[pos].element.x = x;
h->theCells[pos].element.y = y;
h->theCells[pos].info = Legitimate;
h->hasInsertedNum++;
}
return h;
}

HashTable rehash(HashTable h) {
HashTable newH = initializeTable(h->tableSize * 2);
for (int i = 0; i < h->tableSize; i++)
if (h->theCells[i].info == Legitimate)
insert(h->theCells[i].element.x, h->theCells[i].element.y, newH);
destroyTable(h);
return newH;
}

YType map(XType x, HashTable h) {
Position p = find(x, h);
return h->theCells[p].element.y;
}

main.cpp

#include<iostream>
#include<sstream>
#include<string>
#include<vector>
#include"hashQuad.h"

int main() {
HashTable h = initializeTable(200);
int newNumCnt = 0xf;//从f处开始
std::vector<std::string> proc;
std::string line;
while (std::getline(std::cin, line)) {
std::stringstream ss(line);
std::string word;
std::string changed_line;
ss >> word;//读入原序列
int ori_num = std::stoi(word);
int new_num = newNumCnt;
char buff[20];
changed_line += itoa(newNumCnt, buff, 16);
changed_line += ' ';
newNumCnt += 0xd;
h = insert(ori_num, new_num, h);
while (ss >> word) {
if (word == "GOTO" || word == "GOSUB") {
changed_line += word;
changed_line += ' ';
ss >> word;
changed_line += itoa(map(atoi(word.c_str()), h), buff, 16);
}
else {
changed_line += word;
changed_line += ' ';
}
}
proc.push_back(changed_line);
}
for (const auto &str : proc) {
std::cout << str << std::endl;
}
}