update

DSBookCode/BookCode/第3章/3.1-3.4/3.1-3.4.cpp

@@ -0,0 +1,117 @@
+/***顺序栈的实现***/
+
+#include<iostream>
+#include<fstream>
+using namespace std;
+
+//顺序栈定义
+#define OK 1
+#define ERROR 0
+#define OVERFLOW -2
+#define MAXSIZE  100//顺序栈存储空间的初始分配量
+typedef int Status;
+typedef char SElemType;
+
+typedef struct {
+	SElemType *base;//栈底指针
+	SElemType *top;//栈顶指针
+	int stacksize;//栈可用的最大容量
+} SqStack;
+
+//算法3.1　顺序栈的初始化
+Status InitStack(SqStack &S) {
+	//构造一个空栈S
+	S.base = new SElemType[MAXSIZE];//为顺序栈动态分配一个最大容量为MAXSIZE的数组空间
+	if (!S.base)
+		exit(OVERFLOW); //存储分配失败
+	S.top = S.base; //top初始为base，空栈
+	S.stacksize = MAXSIZE; //stacksize置为栈的最大容量MAXSIZE
+	return OK;
+}
+//算法3.2　顺序栈的入栈
+Status Push(SqStack &S, SElemType e) {
+	// 插入元素e为新的栈顶元素
+	if (S.top - S.base == S.stacksize)
+		return ERROR; //栈满
+	*(S.top++) = e; //元素e压入栈顶，栈顶指针加1
+	return OK;
+}
+//算法3.3　顺序栈的出栈
+Status Pop(SqStack &S, SElemType &e) {
+	//删除S的栈顶元素，用e返回其值	
+	if (S.base == S.top)
+		return ERROR;//栈空
+	e = *(--S.top); //栈顶指针减1，将栈顶元素赋给e
+	return OK;
+}
+//算法3.4　取顺序栈的栈顶元素
+char GetTop(SqStack S) {//返回S的栈顶元素，不修改栈顶指针
+	if (S.top != S.base) //栈非空
+		return *(S.top - 1); //返回栈顶元素的值，栈顶指针不变
+}
+
+int main() {
+	SqStack s;
+	int choose, flag = 0;
+	SElemType j, e, t;
+	cout << "1.初始化\n";
+	cout << "2.入栈\n";
+	cout << "3.读栈顶元素\n";
+	cout << "4.出栈\n";
+	cout << "0.退出\n\n";
+
+	choose = -1;
+	while (choose != 0) {
+		cout << "请选择:";
+		cin >> choose;
+		switch (choose) {
+		case 1://算法3.1　顺序栈的初始化
+			if (InitStack(s)) {
+				flag = 1;
+				cout << "成功对栈进行初始化\n\n";
+			} else
+				cout << "初始化栈失败\n\n";
+			break;
+		case 2: {//算法3.2　顺序栈的入栈
+			fstream file;
+			file.open("SqStack.txt");//
+			if (!file) {
+				cout << "错误！未找到文件！\n\n" << endl;
+				exit(ERROR);
+			}
+			if (flag) {
+				flag = 1;
+				cout << "进栈元素依次为：\n";
+				while (!file.eof()) {
+					file >> j;
+					if (file.fail())
+						break;
+					else {
+						Push(s, j);
+						cout << j << "  ";
+					}
+				}
+				cout << endl << endl;
+			} else
+				cout << "栈未建立，请重新选择\n\n";
+			file.close();
+		}
+			break;
+		case 3://算法3.3　顺序栈的出栈
+			if(flag != -1 && flag != 0)
+				cout << "栈顶元素为：\n" << GetTop(s) << endl << endl;
+			else
+				cout << "栈中无元素，请重新选择\n" << endl;
+			break;
+		case 4://算法3.4　取顺序栈的栈顶元素
+			cout << "依次弹出的栈顶元素为:\n";
+			while (Pop(s, t)){
+				flag = -1;
+				cout << t << "  ";
+			}
+			cout << endl << endl;
+			break;
+		}
+	}
+	return 0;
+}

DSBookCode/BookCode/第3章/3.1-3.4/SqStack.txt

@@ -0,0 +1,4 @@
+A
+B
+C
+D

DSBookCode/BookCode/第3章/3.10/3.10.cpp

@@ -0,0 +1,16 @@
+/***Hanoi塔问题***/
+
+#include"3.10.h"
+
+int main() {
+	int n;
+	char a, b, c;
+	a = '1';
+	b = '2';
+	c = '3';
+	cout << "请输入初始第一个柱子上的圆盘个数：" << endl;
+	cin >> n;
+	cout << "将第一个柱子上的圆盘全部移动到第三个柱子上的过程为：" << endl;
+	Hanoi(n, a, b, c);
+	return 0;
+}

DSBookCode/BookCode/第3章/3.10/3.10.h

@@ -0,0 +1,20 @@
+#include<iostream>
+using namespace std;
+
+int m = 0;//（m是初值为0的全局变量，对搬动计数）
+void move(char A, int n, char C) // 搬动操作
+{
+	cout << "第" << ++m << "步," << "将编号为" << n << "的圆盘从第" << A << "个柱子上移到第" << C
+			<< "个柱子上" << endl;
+}
+
+//算法3.10　Hanoi塔问题的递归算法
+void Hanoi(int n, char A, char B, char C) {//将塔座A上的n个圆盘按规则搬到C上，B做辅助塔
+	if (n == 1)
+		move(A, 1, C); //将编号为1的圆盘从A移到C
+	else {
+		Hanoi(n - 1, A, C, B); //将A上编号为1至n-1的圆盘移到B，C做辅助塔
+		move(A, n, C);//将编号为n的圆盘从A移到C
+		Hanoi(n - 1, B, A, C); //将B上编号为1至n-1的圆盘移到C，A做辅助塔
+	}
+}

DSBookCode/BookCode/第3章/3.11-3.15/3.11-3.15.cpp

@@ -0,0 +1,123 @@
+/***循环队列基本操作***/
+
+#include<iostream>
+#include<fstream>
+using namespace std;
+
+#define MAXQSIZE 100
+#define OK 1
+#define ERROR 0
+#define OVERFLOW -2
+typedef char QElemType;
+typedef char SElemType;
+typedef int Status;
+
+typedef struct {
+	QElemType *base;//初始化时动态分配存储空间
+	int front;//头指针
+	int rear;//尾指针
+} SqQueue;
+
+//算法3.11　循环队列的初始化
+Status InitQueue(SqQueue &Q) {//构造一个空队列Q
+	Q.base = new QElemType[MAXQSIZE]; //为队列分配一个最大容量为MAXSIZE的数组空间
+	if (!Q.base)
+		exit(OVERFLOW); //存储分配失败
+	Q.front = Q.rear = 0; //头指针和尾指针置为零，队列为空
+	return OK;
+}
+
+//算法3.12　求循环队列的长度
+int QueueLength(SqQueue Q) {//返回Q的元素个数，即队列的长度
+	return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
+}
+
+//算法3.13　循环队列的入队
+Status EnQueue(SqQueue &Q, QElemType e) {//插入元素e为Q的新的队尾元素
+	if ((Q.rear + 1) % MAXQSIZE == Q.front) //尾指针在循环意义上加1后等于头指针，表明队满
+		return ERROR;
+	Q.base[Q.rear] = e; //新元素插入队尾
+	Q.rear = (Q.rear + 1) % MAXQSIZE; //队尾指针加1
+	return OK;
+}
+
+//算法3.14　循环队列的出队
+Status DeQueue(SqQueue &Q, QElemType &e) {//删除Q的队头元素，用e返回其值
+	if (Q.front == Q.rear)
+		return ERROR; //队空
+	e = Q.base[Q.front]; //保存队头元素
+	Q.front = (Q.front + 1) % MAXQSIZE; //队头指针加1
+	return OK;
+}
+
+//算法3.15　取循环队列的队头元素
+SElemType GetHead(SqQueue Q) {//返回Q的队头元素，不修改队头指针
+	if (Q.front != Q.rear) //队列非空
+		return Q.base[Q.front]; //返回队头元素的值，队头指针不变
+}
+
+int main() {
+	int choose, flag = 0;
+	SqQueue Q;
+	QElemType e, j;
+	cout << "1.初始化\n";
+	cout << "2.入队\n";
+	cout << "3.读队头元素\n";
+	cout << "4.出队\n";
+	cout << "0.退出\n\n";
+
+	choose = -1;
+	while (choose != 0) {
+		cout << "请选择:";
+		cin >> choose;
+		switch (choose) {
+		case 1://算法3.16　链队的初始化
+			if (InitQueue(Q)) {
+				flag = 1;
+				cout << "成功对队列进行初始化\n\n";
+			} else
+				cout << "初始化队列失败\n\n";
+			break;
+		case 2: {//算法3.17　链队的入队
+			fstream file;
+			file.open("QNode.txt");
+			if (!file) {
+				cout << "错误！未找到文件！\n\n" << endl;
+				exit(ERROR);
+			}
+			if (flag) {
+				flag = 1;
+				cout << "入队的元素依次为：\n";
+				while (!file.eof()) {
+					file >> j;
+					if (file.fail())
+						break;
+					else {
+						EnQueue(Q, j);
+						cout << j << "  ";
+					}
+				}
+				cout << endl << endl;
+			} else
+				cout << "队列未建立，请重新选择\n\n";
+			file.close();
+		}
+			break;
+		case 3://算法3.19　取链队的队头元素
+			if (flag != -1 && flag != 0)
+				cout << "队头元素为：\n" << GetHead(Q) << endl << endl;
+			else
+				cout << "队列中无元素，请重新选择\n" << endl;
+			break;
+		case 4://算法3.18　链队的出队
+			cout << "依次弹出的队头元素为:\n";
+			while (DeQueue(Q, e)) {
+				flag = -1;
+				cout << e << "  ";
+			}
+			cout << endl << endl;
+			break;
+		}
+	}
+	return 0;
+}

DSBookCode/BookCode/第3章/3.11-3.15/QNode.txt

@@ -0,0 +1,4 @@
+A
+B
+C
+D

DSBookCode/BookCode/第3章/3.16-3.19/3.16-3.19.cpp

@@ -0,0 +1,126 @@
+/***链队的基本操作***/
+
+#include<iostream>
+#include<fstream>
+using namespace std;
+
+#define OK 1
+#define ERROR 0
+#define OVERFLOW -2
+typedef char QElemType;
+typedef int Status;
+typedef char SElemType;
+
+//- - - - - 队列的链式存储结构- - - - - 
+typedef struct QNode {
+	QElemType data;
+	struct QNode *next;
+} QNode, *QueuePtr;
+typedef struct {
+	QueuePtr front; //队头指针
+	QueuePtr rear; //队尾指针
+} LinkQueue;
+
+//算法3.16　链队的初始化
+Status InitQueue(LinkQueue &Q) {//构造一个空队列Q
+	Q.front = Q.rear = new QNode; //生成新结点作为头结点，队头和队尾指针指向此结点
+	Q.front->next = NULL; //头结点的指针域置空
+	return OK;
+}
+
+//算法3.17　链队的入队
+Status EnQueue(LinkQueue &Q, QElemType e) {//插入元素e为Q的新的队尾元素
+	QueuePtr p;
+	p = new QNode; //为入队元素分配结点空间，用指针p指向
+	p->data = e; //将新结点数据域置为e
+	p->next = NULL;
+	Q.rear->next = p; //将新结点插入到队尾
+	Q.rear = p; //修改队尾指针
+	return OK;
+}
+
+//算法3.18　链队的出队
+Status DeQueue(LinkQueue &Q, QElemType &e) {//删除Q的队头元素，用e返回其值 
+	QueuePtr p;
+	if (Q.front == Q.rear)
+		return ERROR; //若队列空，则返回ERROR
+	p = Q.front->next; //p指向队头元素
+	e = p->data; //e保存队头元素的值
+	Q.front->next = p->next; //修改头指针
+	if (Q.rear == p)
+		Q.rear = Q.front; //最后一个元素被删，队尾指针指向头结点
+	delete p; //释放原队头元素的空间
+	return OK;
+}
+
+//算法3.19　取链队的队头元素
+SElemType GetHead(LinkQueue Q) {//返回Q的队头元素，不修改队头指针
+	if (Q.front != Q.rear) //队列非空
+		return Q.front->next->data; //返回队头元素的值，队头指针不变
+}
+
+int main() {
+	int choose, flag = 0;
+	LinkQueue Q;
+	QElemType e, j;
+	cout << "1.初始化\n";
+	cout << "2.入队\n";
+	cout << "3.读队头元素\n";
+	cout << "4.出队\n";
+	cout << "0.退出\n\n";
+
+	choose = -1;
+	while (choose != 0) {
+		cout << "请选择:";
+		cin >> choose;
+		switch (choose) {
+		case 1://算法3.16　链队的初始化
+			if (InitQueue(Q)) {
+				flag = 1;
+				cout << "成功对队列进行初始化\n\n";
+			} else
+				cout << "初始化队列失败\n\n";
+			break;
+		case 2: {//算法3.17　链队的入队
+			fstream file;
+			file.open("QNode.txt");
+			if (!file) {
+				cout << "错误！未找到文件！\n\n" << endl;
+				exit(ERROR);
+			}
+			if (flag) {
+				flag = 1;
+				cout << "入队的元素依次为：\n";
+				while (!file.eof()) {
+					file >> j;
+					if (file.fail())
+						break;
+					else {
+						EnQueue(Q, j);
+						cout << j << "  ";
+					}
+				}
+				cout << endl << endl;
+			} else
+				cout << "队列未建立，请重新选择\n\n";
+			file.close();
+		}
+			break;
+		case 3://算法3.19　取链队的队头元素
+			if (flag != -1 && flag != 0)
+				cout << "队头元素为：\n" << GetHead(Q) << endl << endl;
+			else
+				cout << "队列中无元素，请重新选择\n" << endl;
+			break;
+		case 4://算法3.18　链队的出队
+			cout << "依次弹出的队头元素为:\n";
+			while (DeQueue(Q, e)) {
+				flag = -1;
+				cout << e << "  ";
+			}
+			cout << endl << endl;
+			break;
+		}
+	}
+	return 0;
+}

DSBookCode/BookCode/第3章/3.16-3.19/QNode.txt

@@ -0,0 +1,4 @@
+A
+B
+C
+D

DSBookCode/BookCode/第3章/3.20/3.20.cpp

@@ -0,0 +1,69 @@
+/***链栈实现数制的转换***/
+
+#include<iostream>
+using namespace std;
+
+#define OK 1
+#define ERROR 0
+#define OVERFLOW -2
+
+typedef int Status;
+typedef struct SNode {
+	int data;
+	struct SNode *next;
+} SNode, *LinkStack;
+
+Status InitStack(LinkStack &S) {
+	S = NULL;
+	return OK;
+}
+bool StackEmpty(LinkStack S) {
+	if (!S)
+		return true;
+	return false;
+}
+Status Push(LinkStack &S, int e) {
+	LinkStack p;
+	p = new SNode;
+	if (!p) {
+		return OVERFLOW;
+	}
+	p->data = e;
+	p->next = S;
+	S = p;
+	return OK;
+}
+Status Pop(LinkStack &S, int &e) {
+	LinkStack p;
+	if (!S)
+		return ERROR;
+	e = S->data;
+	p = S;
+	S = S->next;
+	delete p;
+	return OK;
+}
+//算法3.20　数制的转换(链栈实现)
+void conversion(int N) {//对于任意一个非负十进制数，打印输出与其等值的八进制数
+	int e;
+	LinkStack S;
+	InitStack(S); //初始化空栈S
+	while (N) //当N非零时,循环
+	{
+		Push(S, N % 8); //把N与8求余得到的八进制数压入栈S
+		N = N / 8; //N更新为N与8的商
+	}
+	while (!StackEmpty(S)) //当栈S非空时，循环
+	{
+		Pop(S, e); //弹出栈顶元素e
+		cout << e; //输出e
+	}
+}
+int main() {//对于输入的任意一个非负十进制数，打印输出与其等值的八进制数
+	int n, e;
+	cout << "输入一个非负十进制数:" << endl;
+	cin >> n;
+
+	conversion(n);
+	return 0;
+}

DSBookCode/BookCode/第3章/3.21/3.21.cpp

@@ -0,0 +1,96 @@
+/***链栈实现括号匹配***/
+
+#include<iostream>
+using namespace std;
+
+#define OK 1
+#define ERROR 0
+#define OVERFLOW -2
+typedef char SElemType;
+typedef int Status;
+typedef struct SNode {
+	int data;
+	struct SNode *next;
+} SNode, *LinkStack;
+
+Status InitStack(LinkStack &S) {
+	S = NULL;
+	return OK;
+}
+bool StackEmpty(LinkStack S) {
+	if (!S)
+		return true;
+	return false;
+}
+Status Push(LinkStack &S, SElemType e) {
+	SNode *p = new SNode;
+	if (!p) {
+		return OVERFLOW;
+	}
+	p->data = e;
+	p->next = S;
+	S = p;
+	return OK;
+}
+Status Pop(LinkStack &S, SElemType &e) {
+	SNode *p;
+	if (!S)
+		return ERROR;
+	e = S->data;
+	p = S;
+	S = S->next;
+	delete p;
+	return OK;
+}
+Status GetTop(LinkStack &S) {
+	if (!S)
+		return ERROR;
+	return S->data;
+}
+
+//算法3.21　括号的匹配
+Status Matching() {//检验表达式中所含括号是否正确匹配，如果匹配，则返回true，否则返回false
+	//表达式以“#”结束
+	char ch;
+	SElemType x;
+	LinkStack S;
+	InitStack(S); //初始化空栈
+	int flag = 1; //标记匹配结果以控制循环及返回结果
+	cin >> ch; //读入第一个字符
+	while (ch != '#' && flag) //假设表达式以“#”结尾
+	{
+		switch (ch) {
+		case '[' :
+		case '(': //若是左括号，则将其压入栈
+			Push(S, ch);
+			break;
+		case ')': //若是“)”，则根据当前栈顶元素的值分情况考虑
+			if (!StackEmpty(S) && GetTop(S) == '(')
+				Pop(S, x); //若栈非空且栈顶元素是“(”，则正确匹配
+			else
+				flag = 0; //若栈空或栈顶元素不是“(”，则错误失败
+			break;
+		case ']': //若是“]”，则根据当前栈顶元素的值分情况考虑
+			if (!StackEmpty(S) && GetTop(S) == '[')
+				Pop(S, x); //若栈非空且栈顶元素是“[”，则正确匹配
+			else
+				flag = 0; //若栈空或栈顶元素不是“[”，则错误匹配
+			break;
+		} //switch
+		cin >> ch; //继续读入下一个字符
+	} //while
+	if (StackEmpty(S) && flag)
+		return true; //匹配成功
+	else
+		return false; //匹配失败
+}
+int main() {
+	LinkStack S;
+	cout << "请输入待匹配的表达式，以“#”结束：" << endl;
+	int flag = (int) Matching();
+	if (flag)
+		cout << "括号匹配成功！" << endl;
+	else
+		cout << "括号匹配失败！" << endl;
+	return 0;
+}

DSBookCode/BookCode/第3章/3.22/3.22.cpp

@@ -0,0 +1,29 @@
+#include"3.22.h"
+
+int menu() {
+	int c;
+	cout << "0-9以内的多项式计算" << endl;
+	cout << "1.计算" << endl;
+	cout << "0.退出\n" << endl;
+	cout << "选择：";
+	cin >> c;
+	return c;
+}
+
+void main() {
+	while (1) {
+		switch (menu()) {
+		case 1: {
+			cout << "请输入要计算的表达式（操作数和结果都在0-9的范围内，以#结束）：" << endl;
+			char res = EvaluateExpression();//算法3.22　表达式求值
+			cout << "计算结果为" << res - 48 << endl << endl;
+		}
+			break;
+		case 0:
+			cout << "退出成功\n" << endl;
+			exit(0);
+		default:
+			break;
+		}
+	}
+}

DSBookCode/BookCode/第3章/3.22/3.22.h

@@ -0,0 +1,117 @@
+/***链栈实现表达式求值***/
+
+#include<iostream>
+using namespace std;
+
+const char oper[7] = { '+', '-', '*', '/', '(', ')', '#' };
+#define OK 1
+#define ERROR 0
+#define OVERFLOW -2
+typedef char SElemType;
+typedef int Status;
+typedef struct SNode {
+	int data;
+	struct SNode *next;
+} SNode, *LinkStack;
+
+Status InitStack(LinkStack &S) {
+	S = NULL;
+	return OK;
+}
+bool StackEmpty(LinkStack S) {
+	if (!S)
+		return true;
+	return false;
+}
+Status Push(LinkStack &S, SElemType e) {
+	SNode *p = new SNode;
+	if (!p) {
+		return OVERFLOW;
+	}
+	p->data = e;
+	p->next = S;
+	S = p;
+	return OK;
+}
+Status Pop(LinkStack &S, SElemType &e) {
+	SNode *p;
+	if (!S)
+		return ERROR;
+	e = S->data;
+	p = S;
+	S = S->next;
+	delete p;
+	return OK;
+}
+Status GetTop(LinkStack &S) {
+	if (!S)
+		return ERROR;
+
+	return S->data;
+}
+bool In(char ch) {//判断ch是否为运算符
+	for (int i = 0; i < 7; i++) {
+		if (ch == oper[i]) {
+			return true;
+		}
+	}
+	return false;
+}
+char Precede(char theta1, char theta2) {//判断运算符优先级
+	if ((theta1 == '(' && theta2 == ')') || (theta1 == '#' && theta2 == '#')) {
+		return '=';
+	} else if (theta1 == '(' || theta1 == '#' || theta2 == '(' || (theta1
+			== '+' || theta1 == '-') && (theta2 == '*' || theta2 == '/')) {
+		return '<';
+	} else
+		return '>';
+}
+char Operate(char first, char theta, char second) {//计算两数运算结果
+	switch (theta) {
+	case '+':
+		return (first - '0') + (second - '0') + 48;
+	case '-':
+		return (first - '0') - (second - '0') + 48;
+	case '*':
+		return (first - '0') * (second - '0') + 48;
+	case '/':
+		return (first - '0') / (second - '0') + 48;
+	}
+	return 0;
+}
+
+//算法3.22　表达式求值
+char EvaluateExpression() {//算术表达式求值的算符优先算法，设OPTR和OPND分别为运算符栈和操作数栈
+	LinkStack OPTR, OPND;
+	char ch, theta, a, b, x, top;
+	InitStack(OPND); //初始化OPND栈
+	InitStack(OPTR); //初始化OPTR栈
+	Push(OPTR, '#'); //将表达式起始符“#”压入OPTR栈
+	cin >> ch;
+	while (ch != '#' || (GetTop(OPTR) != '#')) //表达式没有扫描完毕或OPTR的栈顶元素不为“#”
+	{
+		if (!In(ch)) {
+			Push(OPND, ch);
+			cin >> ch;
+		} //ch不是运算符则进OPND栈
+		else
+			switch (Precede(GetTop(OPTR), ch)) //比较OPTR的栈顶元素和ch的优先级
+			{
+			case '<':
+				Push(OPTR, ch);
+				cin >> ch; //当前字符ch压入OPTR栈，读入下一字符ch
+				break;
+			case '>':
+				Pop(OPTR, theta); //弹出OPTR栈顶的运算符
+				Pop(OPND, b);
+				Pop(OPND, a); //弹出OPND栈顶的两个运算数
+				Push(OPND, Operate(a, theta, b)); //将运算结果压入OPND栈
+				break;
+			case '=': //OPTR的栈顶元素是“(”且ch是“)”
+				Pop(OPTR, x);
+				cin >> ch; //弹出OPTR栈顶的“(”，读入下一字符ch
+				break;
+			} //switch
+	} //while
+	return GetTop(OPND); //OPND栈顶元素即为表达式求值结果
+}

DSBookCode/BookCode/第3章/3.23/3.23.cpp

@@ -0,0 +1,18 @@
+#include"3.23.h"
+
+Person dancer[MAXQSIZE];
+int main() {
+	int i = 0;
+	fstream file;
+	file.open("DancePartner.txt");
+	if (!file) {
+		cout << "错误！未找到文件！\n\n" << endl;
+		exit( ERROR);
+	}
+	while (!file.eof()) {
+		file >> dancer[i].name >> dancer[i].sex;
+		i++;
+	}
+	DancePartner(dancer, i + 1);
+	return 0;
+}

DSBookCode/BookCode/第3章/3.23/3.23.h

@@ -0,0 +1,89 @@
+#include<iostream>
+#include<fstream>
+#include<string>
+#define MAXQSIZE 100//队列可能达到的最大长度
+#define OK 1
+#define ERROR 0
+#define OVERFLOW -2
+using namespace std;
+
+typedef struct {
+	char name[20]; //姓名
+	char sex; //性别，'F'表示女性，'M'表示男性
+} Person;
+
+//- - - - - 队列的顺序存储结构- - - - - 
+typedef struct {
+	Person *base; //队列中数据元素类型为Person
+	int front; //头指针
+	int rear; //尾指针
+} SqQueue;
+
+SqQueue Mdancers, Fdancers; //分别存放男士和女士入队者队列
+
+int InitQueue(SqQueue &Q) {//构造一个空队列Q
+	Q.base = new Person[MAXQSIZE]; //为队列分配一个最大容量为MAXSIZE的数组空间
+	if (!Q.base)
+		exit( OVERFLOW); //存储分配失败
+	Q.front = Q.rear = 0; //头指针和尾指针置为零，队列为空
+	return OK;
+}
+
+int EnQueue(SqQueue &Q, Person e) {//插入元素e为Q的新的队尾元素
+	if ((Q.rear + 1) % MAXQSIZE == Q.front) //尾指针在循环意义上加1后等于头指针，表明队满
+		return ERROR;
+	Q.base[Q.rear] = e; //新元素插入队尾
+	Q.rear = (Q.rear + 1) % MAXQSIZE; //队尾指针加1
+	return OK;
+}
+
+int QueueEmpty(SqQueue &Q) {
+	if (Q.front == Q.rear) //队空
+		return OK;
+	else
+		return ERROR;
+}
+
+int DeQueue(SqQueue &Q, Person &e)//删除Q的队头元素，用e返回其值
+{
+	if (Q.front == Q.rear)
+		return ERROR; //队空
+	e = Q.base[Q.front]; //保存队头元素
+	Q.front = (Q.front + 1) % MAXQSIZE; //队头指针加1
+	return OK;
+}
+
+Person GetHead(SqQueue Q) {//返回Q的队头元素，不修改队头指针
+	if (Q.front != Q.rear) //队列非空
+		return Q.base[Q.front]; //返回队头元素的值，队头指针不变
+}
+
+//算法3.23　舞伴问题
+void DancePartner(Person dancer[], int num) {//结构数组dancer中存放跳舞的男女，num是跳舞的人数。
+	InitQueue(Mdancers); //男士队列初始化
+	InitQueue(Fdancers); //女士队列初始化
+	Person p;
+	for (int i = 0; i < num; i++) //依次将跳舞者根据其性别入队
+	{
+		p = dancer[i];
+		if (p.sex == 'F')
+			EnQueue(Fdancers, p); //插入女队
+		else
+			EnQueue(Mdancers, p); //插入男队
+	}
+	cout << "The dancing partners are:" << endl;
+	while (!QueueEmpty(Fdancers) && !QueueEmpty(Mdancers)) {//依次输出男女舞伴的姓名
+		DeQueue(Fdancers, p); //女士出队
+		cout << p.name << "  "; //输出出队女士姓名
+		DeQueue(Mdancers, p); //男士出队
+		cout << p.name << endl; //输出出队男士姓名
+	}
+	if (!QueueEmpty(Fdancers)) { //女士队列非空，输出队头女士的姓名
+		p = GetHead(Fdancers); //取女士队头
+		cout << "The first man to get a partner is: " << endl;
+		cout << p.name << endl;
+	} else if (!QueueEmpty(Mdancers)) { //男士队列非空，输出队头男士的姓名
+		p = GetHead(Mdancers); //取男士队头
+		cout << "The first woman to get a partner is: " << p.name << endl;
+	}
+}

DSBookCode/BookCode/第3章/3.23/DancePartner.txt

@@ -0,0 +1,18 @@
+鄢雪棱 F
+高欣雅 F
+张甜源 F
+许丹丹 F
+冉小溪 F
+周如意 F
+胡思琪 F
+蒋雅琪 F
+金城武 M
+吴彦祖 M
+王思聪 M
+古天乐 M
+周杰伦 M
+李敏浩 M
+李钟硕 M
+马小云 M
+张智霖 M
+王力宏 M

DSBookCode/BookCode/第3章/3.5-3.8/3.5-3.8.cpp

@@ -0,0 +1,115 @@
+/***链栈的实现***/
+#include<iostream>
+#include<fstream>
+using namespace std;
+
+#define OK 1
+#define ERROR 0
+#define OVERFLOW -2
+typedef int Status;
+typedef char SElemType;
+
+typedef struct StackNode {
+	SElemType data;
+	struct StackNode *next;
+} StackNode, *LinkStack;
+
+//算法3.5　链栈的初始化
+Status InitStack(LinkStack &S) { // 构造一个空栈 S，栈顶指针置空
+	S = NULL;
+	return OK;
+}
+
+//算法3.6　链栈的入栈
+Status Push(LinkStack &S, SElemType e) {//在栈顶插入元素e
+	LinkStack p;
+	p = new StackNode; //生成新结点
+	p->data = e; //将新结点数据域置为e
+	p->next = S; //将新结点插入栈顶
+	S = p; //修改栈顶指针为p
+	return OK;
+}
+
+//算法3.7　链栈的出栈
+Status Pop(LinkStack &S, SElemType &e) {//删除S的栈顶元素，用e返回其值
+	LinkStack p;
+	if (S == NULL)
+		return ERROR; //栈空
+	e = S->data; //将栈顶元素赋给e
+	p = S; //用p临时保存栈顶元素空间，以备释放
+	S = S->next; //修改栈顶指针
+	delete p; //释放原栈顶元素的空间
+	return OK;
+}
+//算法3.8　取链栈的栈顶元素
+SElemType GetTop(LinkStack S) {//返回S的栈顶元素，不修改栈顶指针
+	if (S != NULL) //栈非空
+		return S->data; //返回栈顶元素的值，栈顶指针不变
+}
+
+int main() {
+	LinkStack s;
+	int choose, flag = 0;
+	SElemType j, t;
+	cout << "1.初始化\n";
+	cout << "2.入栈\n";
+	cout << "3.读栈顶元素\n";
+	cout << "4.出栈\n";
+	cout << "0.退出\n\n";
+
+	choose = -1;
+	while (choose != 0) {
+		cout << "请选择:";
+		cin >> choose;
+		switch (choose) {
+		case 1://算法3.5　链栈的初始化
+			if (InitStack(s)) {
+				flag = 1;
+				cout << "成功对栈进行初始化\n\n";
+			} else
+				cout << "初始化栈失败\n\n";
+			break;
+		case 2: {//算法3.6　链栈的入栈
+			fstream file;
+			file.open("SqStack.txt");
+			if (!file) {
+				cout << "错误！未找到文件！\n\n" << endl;
+				exit(ERROR);
+			}
+			if (flag) {
+				flag = 1;
+				cout << "进栈元素依次为：\n";
+				while (!file.eof()) {
+					file >> j;
+					if (file.fail())
+						break;
+					else {
+						Push(s, j);
+						cout << j << "  ";
+					}
+				}
+				cout << endl << endl;
+			} else
+				cout << "栈未建立，请重新选择\n\n";
+			file.close();
+		}
+			break;
+		case 3://算法3.8　取链栈的栈顶元素
+			if (flag != -1 && flag != 0)
+				cout << "栈顶元素为：\n" << GetTop(s) << endl << endl;
+			else
+				cout << "栈中无元素，请重新选择\n" << endl;
+			break;
+		case 4://算法3.7　链栈的出栈
+			if (flag) {
+				cout << "依次弹出的栈顶元素为:\n";
+				while (Pop(s, t))
+					cout << t << "  ";
+				cout << endl << endl;
+			} else
+				cout << "栈未建立，请重新选择\n\n";
+			break;
+		}
+	}
+	return 0;
+}

DSBookCode/BookCode/第3章/3.5-3.8/SqStack.txt

@@ -0,0 +1,4 @@
+A
+B
+C
+D

DSBookCode/BookCode/第3章/3.9/3.9.cpp

@@ -0,0 +1,53 @@
+/***依次输出链表中的各个结点***/
+
+#include<iostream>
+using namespace std;
+
+#define OK 1
+#define ERROR 0
+#define OVERFLOW -2
+typedef int Status;
+typedef char ElemType;
+typedef struct LNode {
+	ElemType data; //结点的数据域
+	LNode *next; //结点的指针域
+} LNode, *LinkList;//头指针
+
+//后插法创建链表算法
+void CreateList_L(LinkList &L, int n) {
+	L = new LNode;
+	L->next = NULL;
+	LNode *p, *r;
+	r = L;
+	for (int i = 0; i < n; i++) {
+		p = new LNode;
+		cin >> p->data;
+		p->next = NULL;
+		r->next = p;
+		r = p;
+	}
+}
+
+//算法3.9　遍历输出链表中各个结点的递归算法
+void TraverseList(LinkList p) {
+	if (p == NULL)
+		return; //递归终止
+	else {
+		cout << p->data << endl; //输出当前结点的数据域
+		TraverseList(p->next); //p指向后继指点继续递归
+	}
+}
+
+int main() {
+	int n;
+	LinkList L;
+	//InitList(L);
+	cout << "请输入元素个数：" << endl;
+	cin >> n;
+	cout << "请输入链表元素(以空格隔开，按回车结束)：" << endl;
+	CreateList_L(L, n); //后插法创建链表算法
+	cout << "链表中的元素依次为：" << endl;
+	TraverseList(L->next);
+	cout << endl;
+	return 0;
+}