数据结构1、基于线性表的图书信息管理（2）单链表实验

1 题目描述

图1 单链表实验

2 题目解读

        这次实验要求完成单链表的创建、输出，单链表的排序、修改、逆序存储，单链表按位查找、按值查找、增加结点、删除结点。

3 代码与结果

        这一部分给出本次实验的代码与结果。

3.1 基于链式存储结构的图书信息表的创建和输出

        这一题是后面题目的基础，使用尾插法建立单链表，并输出单链表中的各元素值。

3.1.1 设计代码

#include 
#include 
using namespace std;
//函数结果状态代码
#define OK 1
#define ERROR 0
//#define OVERFLOW -2
//Status是函数返回值类型，其值是函数结果状态代码
typedef int Status;
typedef struct         //图书信息定义
{
	char no[20];       //图书ISBN
	char name[50];     //图书名字
	float price;       //图书价格
}Book;
//-----单链表的存储结构-----
typedef struct LNode {
Book data;
	struct LNode* next;
}LNode, *LinkList;
//11.基于链式存储结构的图书信息表的创建和输出
void CreateList_R(LinkList&L);
int Length(LinkList L);
void PrintList(LinkList L);
int main()
{
	LinkList L;
	CreateList_R(L);
	int n = Length(L);
	cout << n << endl;
	PrintList(L);
	return 0;
}
void CreateList_R(LinkList &L)
{
	LNode *r;
	L = new LNode;
	L->next = NULL;
	r = L;
	while (true) {
		LNode *p = new LNode;
		cin >> p->data.no >> p->data.name >> p->data.price;
		p->next = NULL;
		string s1 = p->data.no;
		string s2 = p->data.name;
		if (s1 == "0" && s2 == "0" && p->data.price == 0) {
			delete p;
			break;
		}
		r->next = p;
		r = p;
	}
}
int Length(LinkList L)
{
	int count = 0;
	L = L->next;
	while (L != NULL) {
		count++;
		L = L->next;
	}
	return count;
}
void PrintList(LinkList L)
{
	LNode *p = L->next;
	while (p != NULL) {
		cout << p->data.no << " " << p->data.name << " ";
		//保留小数点后面2位
		cout << fixed << setprecision(2) << p->data.price << endl;
		p = p->next;
	}
}

3.1.2 执行结果

图2 第十一题代码执行结果

3.2 基于链式存储结构的图书信息表的排序

        使用排序算法完成单链表中元素的排序，排序依据是图书信息表中图书的价格。

3.2.1 设计代码

#include 
#include 
using namespace std;
//函数结果状态代码
#define OK 1
#define ERROR 0
//#define OVERFLOW -2
//Status是函数返回值类型，其值是函数结果状态代码
typedef int Status;
typedef struct         //图书信息定义
{
	char no[20];       //图书ISBN
	char name[50];     //图书名字
	float price;       //图书价格
}Book;
//-----单链表的存储结构-----
typedef struct LNode {
	Book data;
	struct LNode *next;
}LNode, *LinkList;
//基于链式存储结构的图书信息表的创建和输出
void CreateList_R(LinkList &L);
int Length(LinkList L);
//12.基于链式存储结构的图书信息表的排序
Status GetElem(LinkList L, int i, Book& e);
Status ModifyElem(LinkList& L, int i, Book e);
void BubbleSort(LinkList& L);
void PrintList(LinkList L);
int main()
{
	LinkList L;
	CreateList_R(L);
	BubbleSort(L);
	PrintList(L);
	return 0;
}
void CreateList_R(LinkList& L) {
	LNode* r;
	L = new LNode;
	L->next = NULL;
	r = L;
	while (true) {
		LNode* p = new LNode;
		cin >> p->data.no >> p->data.name >> p->data.price;
		p->next = NULL;
		string s1 = p->data.no;
		string s2 = p->data.name;
		if (s1 == "0" && s2 == "0" && p->data.price == 0) {
			delete p;
			break;
		}
		r->next = p;
		r = p;
	}
}
int Length(LinkList L) {
	int count = 0;
	L = L->next;
	while (L != NULL) {
		count++;
		L = L->next;
	}
	return count;
}
Status GetElem(LinkList L, int i, Book& e)
{
	LNode* p = L->next; int j = 1;
	while (p && j < i)
	{
		p = p->next;
		++j;
	}
	if (!p || j > i) return ERROR;
	e = p->data;
	return OK;
}
Status ModifyElem(LinkList& L, int i, Book e)
{
	LNode* p = L->next; int j = 1;
	while (p && j < i)
	{
		p = p->next;
		++j;
	}
	if (!p || j > i) return ERROR;
	p->data = e;
	return OK;
}
void BubbleSort(LinkList& L) {
	int m = Length(L) - 1;
	bool flag = true;
	while ((m > 0) && (flag))
	{
		flag = false;
		for (int j = 1; j <= m; j++)
		{
			Book t1, t2;
			GetElem(L, j, t1);
			GetElem(L, j + 1, t2);
			if (t1.price < t2.price)
			{
				flag = true;
				ModifyElem(L, j, t2);
				ModifyElem(L, j + 1, t1);
			}
		}
		m--;
	}
}
void PrintList(LinkList L) {
	LNode* p = L->next;
	while (p != NULL) {
		cout << p->data.no << " " << p->data.name << " ";
		//保留小数点后面2位
		cout << fixed << setprecision(2) << p->data.price << endl;
		p = p->next;
	}
}

3.2.2 执行结果

图3 第十二题代码执行结果

3.3 基于链式存储结构的图书信息表的修改

        修改单链表中各元素的值。

3.3.1 设计代码

#include 
#include 
using namespace std;
//函数结果状态代码
#define OK 1
#define ERROR 0
//#define OVERFLOW -2
//Status是函数返回值类型，其值是函数结果状态代码
typedef int Status;
typedef struct         //图书信息定义
{
	char no[20];       //图书ISBN
	char name[50];     //图书名字
	float price;       //图书价格
}Book;
//-----单链表的存储结构-----
typedef struct LNode {
	Book data;
	struct LNode* next;
}LNode, *LinkList;
//基于链式存储结构的图书信息表的创建和输出
void CreateList_R(LinkList& L);
int Length(LinkList L);
//13.基于链式存储结构的图书信息表的修改
Status GetElem(LinkList L, int i, Book& e);
Status GetAvePrice(LinkList L, double& pr);
Status ModifyPrice(LinkList& L);
void PrintList(LinkList L);
int main()
{
	LinkList L;
	CreateList_R(L);
	ModifyPrice(L);
	PrintList(L);
	return 0;
}
void CreateList_R(LinkList& L) {
	LNode* r;
	L = new LNode;
	L->next = NULL;
	r = L;
	while (true) {
		LNode* p = new LNode;
		cin >> p->data.no >> p->data.name >> p->data.price;
		p->next = NULL;
		string s1 = p->data.no;
		string s2 = p->data.name;
		if (s1 == "0" && s2 == "0" && p->data.price == 0) {
			delete p;
			break;
		}
		r->next = p;
		r = p;
	}
}
int Length(LinkList L) {
	int count = 0;
	L = L->next;
	while (L != NULL) {
		count++;
		L = L->next;
	}
	return count;
}
Status GetElem(LinkList L, int i, Book& e)
{
	LNode* p = L->next; int j = 1;
	while (p && j < i)
	{
		p = p->next;
		++j;
	}
	if (!p || j > i) return ERROR;
	e = p->data;
	return OK;
}
Status GetAvePrice(LinkList L, double& pr)
{
	pr = 0;
	LNode* p = L->next;
	while (p != NULL) {
		pr += p->data.price;
		p = p->next;
	}
	pr /= Length(L);
	printf("%.2f\n", pr);
	return OK;
}
Status ModifyPrice(LinkList& L)
{
	double pr;
	GetAvePrice(L, pr);
	LNode* p = L->next;
	while (p != NULL) {
		if (p->data.price < pr) {
			p->data.price *= float(1.2);
		}
		else {
			p->data.price *= float(1.1);
		}
		p = p->next;
	}
	return OK;
}
void PrintList(LinkList L) {
	LNode* p = L->next;
	while (p != NULL) {
		cout << p->data.no << " " << p->data.name << " ";
		//保留小数点后面2位
		cout << fixed << setprecision(2) << p->data.price << endl;
		p = p->next;
	}
}

3.3.2 执行结果

图4 第十三题代码执行结果

3.4 基于链式存储结构的图书信息表的逆序存储

        将单链表中各元素逆序存储，可以使用头插法重新建表，也可以修改各结点的指针。

3.4.1 设计代码

#include 
#include 
using namespace std;
//函数结果状态代码
#define OK 1
#define ERROR 0
//#define OVERFLOW -2
//Status是函数返回值类型，其值是函数结果状态代码
typedef int Status;
typedef struct         //图书信息定义
{
	char no[20];       //图书ISBN
	char name[50];     //图书名字
	float price;       //图书价格
}Book;
//-----单链表的存储结构-----
typedef struct LNode {
	Book data;
	struct LNode* next;
}LNode, *LinkList;
void CreateList_R(LinkList& L);
int Length(LinkList L);
void PrintList(LinkList L);
//14.基于链式存储结构的图书信息表的逆序存储
Status RevList(LinkList& L);
int main()
{
	LinkList L;
	CreateList_R(L);
	RevList(L);
	PrintList(L);
	return 0;
}
Status RevList(LinkList& L) {
	LNode* p, * r;
	p = L->next;
	L->next = NULL;
	while (p != NULL) {
		r = p->next;
		p->next = L->next;
		L->next = p;
		p = r;
	}
	return OK;
}
void CreateList_R(LinkList& L)
{
	LNode* r;
	L = new LNode;
	L->next = NULL;
	r = L;
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		LNode* p = new LNode;
		cin >> p->data.no >> p->data.name >> p->data.price;
		p->next = NULL;
		r->next = p;
		r = p;
	}
}
int Length(LinkList L)
{
	int count = 0;
	L = L->next;
	while (L != NULL) {
		count++;
		L = L->next;
	}
	return count;
}
void PrintList(LinkList L)
{
	LNode* p = L->next;
	while (p != NULL) {
		cout << p->data.no << " " << p->data.name << " ";
		//保留小数点后面2位
		cout << fixed << setprecision(2) << p->data.price << endl;
		p = p->next;
	}
}

3.4.2 执行结果

图5 第十四题代码执行结果

3.5 基于链式存储结构的图书信息表的最贵图书的查找

        查找单链表中价格最高的图书。

3.5.1 设计代码

#include 
#include 
using namespace std;
//函数结果状态代码
#define OK 1
#define ERROR 0
//#define OVERFLOW -2
//Status是函数返回值类型，其值是函数结果状态代码
typedef int Status;
typedef struct         //图书信息定义
{
	char no[20];       //图书ISBN
	char name[50];     //图书名字
	float price;       //图书价格
}Book;
//-----单链表的存储结构-----
typedef struct LNode {
	Book data;
	struct LNode* next;
}LNode, *LinkList;
Status InitList(LinkList& L);
void CreateList_R(LinkList& L);
int Length(LinkList L);
void PrintList(LinkList L);
//15.基于链式存储结构的图书信息表的最贵图书的查找
Status FindExpensiveBooks(LinkList L);
int main()
{
	LinkList L;
	CreateList_R(L);
	FindExpensiveBooks(L);
	return 0;
}
Status FindExpensiveBooks(LinkList L)
{
	LNode* p = L->next;
	float pr = p->data.price;
	while (p != NULL) {
		if (p->data.price > pr) {
			pr = p->data.price;
		}
		p = p->next;
	}
	LinkList AL;
	InitList(AL);
	LNode* r = AL;
	p = L->next;
	int count = 0;
	while (p != NULL) {
		if (p->data.price == pr) {
			r->next = p;
			r = p;
			count++;
		}
		p = p->next;
	}
	r->next = NULL;
	cout << count << endl;
	PrintList(AL);
	return OK;
}
Status InitList(LinkList& L)
{
	L = new LNode;
	L->next = NULL;
	return OK;
}
void CreateList_R(LinkList& L)
{
	LNode* r;
	L = new LNode;
	L->next = NULL;
	r = L;
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		LNode* p = new LNode;
		cin >> p->data.no >> p->data.name >> p->data.price;
		p->next = NULL;
		r->next = p;
		r = p;
	}
}
int Length(LinkList L)
{
	int count = 0;
	L = L->next;
	while (L != NULL) {
		count++;
		L = L->next;
	}
	return count;
}
void PrintList(LinkList L)
{
	LNode* p = L->next;
	while (p != NULL) {
		cout << p->data.no << " " << p->data.name << " ";
		//保留小数点后面2位
		cout << fixed << setprecision(2) << p->data.price << endl;
		p = p->next;
	}
}

3.5.2 执行结果

图6 第十五题代码执行结果

3.6 基于链式存储结构的图书信息表的最爱图书的查找

        根据图书名，在单链表中查找图书。

3.6.1 设计代码

#include 
#include 
using namespace std;
//函数结果状态代码
#define OK 1
#define ERROR 0
//#define OVERFLOW -2
//Status是函数返回值类型，其值是函数结果状态代码
typedef int Status;
typedef struct         //图书信息定义
{
	char no[20];       //图书ISBN
	char name[50];     //图书名字
	float price;       //图书价格
}Book;
//-----单链表的存储结构-----
typedef struct LNode {
	Book data;
	struct LNode* next;
}LNode, *LinkList;
Status InitList(LinkList& L);
void CreateList_R(LinkList& L);
int Length(LinkList L);
void PrintList(LinkList L);
//16.基于链式存储结构的图书信息表的最爱图书的查找
Status FindFavoriteBooks(LinkList L);
int main()
{
	LinkList L;
	CreateList_R(L);
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		FindFavoriteBooks(L);
	}
	return 0;
}
Status FindFavoriteBooks(LinkList L)
{
	LinkList AL;
	InitList(AL);
	LNode* r = AL;
	LNode* s = new LNode;
	cin >> s->data.name;
	LNode* p = L->next;
	int count = 0;
	while (p != NULL) {
		if (strcmp(p->data.name, s->data.name) == 0)
		{
			count++;
			r->next = p;
			r = p;
		}
		p = p->next;
	}
	r->next = NULL;
	delete s;
	r = AL->next;
	if (!r) {
		cout << "Sorry，there is no your favourite!" << endl;
	}
	else {
		cout << count << endl;
		PrintList(AL);
	}
	return OK;
}
Status InitList(LinkList& L)
{
	L = new LNode;
	L->next = NULL;
	return OK;
}
void CreateList_R(LinkList& L)
{
	LNode* r;
	L = new LNode;
	L->next = NULL;
	r = L;
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		LNode* p = new LNode;
		cin >> p->data.no >> p->data.name >> p->data.price;
		p->next = NULL;
		r->next = p;
		r = p;
	}
}
int Length(LinkList L)
{
	int count = 0;
	L = L->next;
	while (L != NULL) {
		count++;
		L = L->next;
	}
	return count;
}
void PrintList(LinkList L)
{
	LNode* p = L->next;
	while (p != NULL) {
		cout << p->data.no << " " << p->data.name << " ";
		//保留小数点后面2位
		cout << fixed << setprecision(2) << p->data.price << endl;
		p = p->next;
	}
}

3.6.2 执行结果

图7 第十六题代码执行结果

3.7 基于链式存储结构的图书信息表的最佳位置图书的查找

        在单链表中按位查找元素。

3.7.1 设计代码

#include 
#include 
using namespace std;
//函数结果状态代码
#define OK 1
#define ERROR 0
//#define OVERFLOW -2
//Status是函数返回值类型，其值是函数结果状态代码
typedef int Status;
typedef struct         //图书信息定义
{
	char no[20];       //图书ISBN
	char name[50];     //图书名字
	float price;       //图书价格
}Book;
//-----单链表的存储结构-----
typedef struct LNode {
	Book data;
	struct LNode* next;
}LNode, *LinkList;
Status InitList(LinkList& L);
void CreateList_R(LinkList& L);
int Length(LinkList L);
//void PrintList(LinkList L);
//17.基于链式存储结构的图书信息表的最佳位置图书的查找
Status FindBestStation(LinkList L);
int main()
{
	LinkList L;
	CreateList_R(L);
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		FindBestStation(L);
	}
	return 0;
}
Status FindBestStation(LinkList L)
{
	int x;
	cin >> x;
	int j = 1;
	LNode* p = L->next;
	while (p && j < x) {
		p = p->next;
		j++;
	}
	if (!p || j > x) {
		cout << "Sorry，the book on the best position doesn't exist!" << endl;
		return ERROR;
	}
	cout << p->data.no << " " << p->data.name << " ";
	cout << fixed << setprecision(2) << p->data.price << endl;
	return OK;
}
Status InitList(LinkList& L)
{
	L = new LNode;
	L->next = NULL;
	return OK;
}
void CreateList_R(LinkList& L)
{
	LNode* r;
	L = new LNode;
	L->next = NULL;
	r = L;
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		LNode* p = new LNode;
		cin >> p->data.no >> p->data.name >> p->data.price;
		p->next = NULL;
		r->next = p;
		r = p;
	}
}
int Length(LinkList L)
{
	int count = 0;
	L = L->next;
	while (L != NULL) {
		count++;
		L = L->next;
	}
	return count;
}
void PrintList(LinkList L)
{
	LNode* p = L->next;
	while (p != NULL) {
		cout << p->data.no << " " << p->data.name << " ";
		//保留小数点后面2位
		cout << fixed << setprecision(2) << p->data.price << endl;
		p = p->next;
	}
}

3.7.2 执行结果

图8 第十七题代码执行结果

3.8 基于链式存储结构的图书信息表的新图书的入库

        将图书信息插入在单链表的给定位置上。

3.8.1 设计代码

#include 
#include 
using namespace std;
//函数结果状态代码
#define OK 1
#define ERROR 0
//#define OVERFLOW -2
//Status是函数返回值类型，其值是函数结果状态代码
typedef int Status;
typedef struct         //图书信息定义
{
	char no[20];       //图书ISBN
	char name[50];     //图书名字
	float price;       //图书价格
}Book;
//-----单链表的存储结构-----
typedef struct LNode {
	Book data;
	struct LNode* next;
}LNode, *LinkList;
Status InitList(LinkList& L);
void CreateList_R(LinkList& L);
int Length(LinkList L);
void PrintList(LinkList L);
//18.基于链式存储结构的图书信息表的新图书的入库
Status ListInsert(LinkList& L, int i, Book e);
int main()
{
	LinkList L;
	CreateList_R(L);
	int x;
	cin >> x;
	Book e;
	cin >> e.no >> e.name >> e.price;
	bool flag;
	flag = ListInsert(L, x, e);
	if (flag) {
		PrintList(L);
	}
	else {
		cout << "Sorry，the position to be inserted is invalid!" << endl;
	}
	return 0;
}
Status ListInsert(LinkList& L, int i, Book e)
{
	LNode* p = L;
	int j = 0;
	while (p && (j < i - 1)) {
		p = p->next;
		++j;
	}
	if (!p || j > i - 1) {
		return ERROR;
	}
	LNode* s = new LNode;
	s->data = e;
	s->next = p->next;
	p->next = s;
	return OK;
}
Status InitList(LinkList& L)
{
	L = new LNode;
	L->next = NULL;
	return OK;
}
void CreateList_R(LinkList& L)
{
	LNode* r;
	L = new LNode;
	L->next = NULL;
	r = L;
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		LNode* p = new LNode;
		cin >> p->data.no >> p->data.name >> p->data.price;
		p->next = NULL;
		r->next = p;
		r = p;
	}
}
int Length(LinkList L)
{
	int count = 0;
	L = L->next;
	while (L != NULL) {
		count++;
		L = L->next;
	}
	return count;
}
void PrintList(LinkList L)
{
	LNode* p = L->next;
	while (p != NULL) {
		cout << p->data.no << " " << p->data.name << " ";
		//保留小数点后面2位
		cout << fixed << setprecision(2) << p->data.price << endl;
		p = p->next;
	}
}

3.8.2 执行结果

图9 第十八题代码执行结果

3.9 基于链式存储结构的图书信息表的旧图书的出库

        删除单链表中给定位置的结点。

3.9.1 设计代码

#include 
#include 
using namespace std;
//函数结果状态代码
#define OK 1
#define ERROR 0
//#define OVERFLOW -2
//Status是函数返回值类型，其值是函数结果状态代码
typedef int Status;
typedef struct         //图书信息定义
{
	char no[20];       //图书ISBN
	char name[50];     //图书名字
	float price;       //图书价格
}Book;
//-----单链表的存储结构-----
typedef struct LNode {
	Book data;
	struct LNode* next;
}LNode, *LinkList;
Status InitList(LinkList& L);
void CreateList_R(LinkList& L);
int Length(LinkList L);
void PrintList(LinkList L);
//19.基于链式存储结构的图书信息表的旧图书的出库
Status ListDelete(LinkList& L, int i);
int main()
{
	LinkList L;
	CreateList_R(L);
	int x;
	cin >> x;
	bool flag;
	flag = ListDelete(L, x);
	if (flag) {
		PrintList(L);
	}
	else {
		cout << "Sorry，the position to be deleted is invalid!" << endl;
	}
	return 0;
}
Status ListDelete(LinkList& L, int i)
{
	LNode* p = L;
	int j = 0;
	while ((p->next) && (j < i - 1)) {
		p = p->next;
		++j;
	}
	if (!(p->next) || j > i - 1) {
		return ERROR;
	}
	LNode* q = p->next;
	p->next = q->next;
	delete q;
	return OK;
}
Status InitList(LinkList& L)
{
	L = new LNode;
	L->next = NULL;
	return OK;
}
void CreateList_R(LinkList& L)
{
	LNode* r;
	L = new LNode;
	L->next = NULL;
	r = L;
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		LNode* p = new LNode;
		cin >> p->data.no >> p->data.name >> p->data.price;
		p->next = NULL;
		r->next = p;
		r = p;
	}
}
int Length(LinkList L)
{
	int count = 0;
	L = L->next;
	while (L != NULL) {
		count++;
		L = L->next;
	}
	return count;
}
void PrintList(LinkList L)
{
	LNode* p = L->next;
	while (p != NULL) {
		cout << p->data.no << " " << p->data.name << " ";
		//保留小数点后面2位
		cout << fixed << setprecision(2) << p->data.price << endl;
		p = p->next;
	}
}

3.9.2 执行结果

图10 第十九题代码执行结果

3.10 基于链式存储结构的图书信息表的图书去重

        对于单链表中有重复书号的结点，保留第一次出现的结点，删除其他的结点。

3.10.1 设计代码

#include 
#include 
using namespace std;
//函数结果状态代码
#define OK 1
#define ERROR 0
//#define OVERFLOW -2
//Status是函数返回值类型，其值是函数结果状态代码
typedef int Status;
typedef struct         //图书信息定义
{
	char no[20];       //图书ISBN
	char name[50];     //图书名字
	float price;       //图书价格
}Book;
//-----单链表的存储结构-----
typedef struct LNode {
	Book data;
	struct LNode* next;
}LNode, *LinkList;
Status InitList(LinkList& L);
void CreateList_R(LinkList& L);
int Length(LinkList L);
void PrintList(LinkList L);
//20.基于链存储结构的图书信息表的图书去重
Status LocateElem(LinkList L, char bno[]);
Status ListDels(LinkList& L);
int main()
{
	LinkList L;
	CreateList_R(L);
	ListDels(L);
	cout << Length(L) << endl;
	PrintList(L);
	return 0;
}
Status LocateElem(LinkList L, char bno[])
{
	LNode* p = L->next;
	string s1, s2;
	if (p != NULL) {
		s1 = p->data.no;
		s2 = bno;
	}
	while (p && s1 != s2) {
		p = p->next;
		if (p != NULL) {
			s1 = p->data.no;
			s2 = bno;
		}
	}
	if (!p) {
		return ERROR;
	}
	return OK;
}
Status ListDels(LinkList& L)
{
	LNode* r = L, * p = L->next;
	r->next = NULL;
	while (p != NULL) {
		if (!LocateElem(L, p->data.no)) {
			LNode* s = p;
			p = p->next;
			s->next = NULL;
			r->next = s;
			r = s;
		}
		else {
			p = p->next;
		}
	}
	return OK;
}

Status InitList(LinkList& L)
{
	L = new LNode;
	L->next = NULL;
	return OK;
}
void CreateList_R(LinkList& L)
{
	LNode* r;
	L = new LNode;
	L->next = NULL;
	r = L;
	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		LNode* p = new LNode;
		cin >> p->data.no >> p->data.name >> p->data.price;
		p->next = NULL;
		r->next = p;
		r = p;
	}
}
int Length(LinkList L)
{
	int count = 0;
	L = L->next;
	while (L != NULL) {
		count++;
		L = L->next;
	}
	return count;
}
void PrintList(LinkList L)
{
	LNode* p = L->next;
	while (p != NULL) {
		cout << p->data.no << " " << p->data.name << " ";
		//保留小数点后面2位
		cout << fixed << setprecision(2) << p->data.price << endl;
		p = p->next;
	}
}

3.10.2 执行结果

图11 第二十题代码执行结果

4 解题心得

• 单链表，是线性表的链式存储表示，与顺序表共同组成了线性表。
• 线性表的链式存储结构与线性表的顺序存储结构，是线性表两种不同的存储结构。
• 对于链表的各种操作，单链表的创建和输出是其他操作的基础，单链表的输出用于单链表各操作的验证。