线性表的链式存储之元素结点构成

例 (1)让计算机产生出20个0一99之间的随机整数并利用数组把它们按升序链接起来;
    (2)按照随机数产生的顺序显示出它们;
    (3)按照升序链接的顺序显示出它们;
    (4)按照升序链接的顺序显示出它们，并显示出它们之间的链接指针，要求每个结点的显示格式为“( data域值，next域值)”，并且规定每行显示7个结点数据;
    (5)把该数组写人到文件、:xxkl . dat'，中;

    (6)把文件“a : xxk 1. dat'，中的所有内容读人到数组，然后按升序显示出其值最小的5个元素

.h文件：

/*由元素结点构成的单链表*/
/*
下标为0的元素的指针域保存表头指针；
当一个结点无后继结点时，指针域为0，表示空指针
最大长度为MaxSize - 2
*/

//初始化
void InitList(ALinkList AL)
{
	AL[0].next = 0;  //将单链表置空，下标0结点为表头附加结点
	for(int i = 1; i< MaxSize - 1; i++)
		AL[i].next = i + 1;   //构成空闲表，其中以下标为1结点的指针域保存空闲表的表头指针
	AL[MaxSize-1].next = 0;  //最后一个结点的指针域置0表示空指针
}

//删除所有结点，与初始化算法相同
void ClearList(ALinkList AL)
{
	AL[0].next = 0;
	for(int i = 1; i< MaxSize - 1; i++)
		AL[i].next = i + 1;
	AL[MaxSize-1].next = 0;
}

//得到单链表的长度
int ListSize(ALinkList AL)
{
	int p = AL[0].next;
	int i = 0;
	while(p != 0)
	{
		i++;
		p = AL[i].next;
	}
	return i;
}

//检查单链表是否为空
int ListEmpty(ALinkList AL)
{
	return (AL[0].next == 0);
}

//得到单链表中第pos个节点的元素
ElemType GetElem(ALinkList AL, int pos)
{
	if(pos < 1)
	{
		cerr<<"pos is out of range!"<<endl;
		exit(1);
	}
	int p = AL[0].next;
	int i = 0;
	while(p != 0)
	{
		i++;
		if(i == pos)
			break;
		p = AL[p].next;
	}
	if(p != 0)
		return AL[p].data;
	else
	{
		cerr<<"pos is out of range!"<<endl;
		exit(1);
	}
}

//遍历并打印一个单链表
void TraverseList(ALinkList AL)
{
	int p = AL[0].next;
	while(p != 0)
	{
		cout<<AL[p].data<<" ";
		p = AL[p].next;
	}
	cout<<endl;
}

//从单链表中查找具有给定值的第一个元素
int Find(ALinkList AL, ElemType &item)
{
	int p = AL[0].next;
	while(p != 0)
	{
		if(AL[p].data == item)
		{
			item = AL[p].data;
			return 1;
		}
		else
			p = AL[p].next;
	}
	return 0;
}

//更新单链表中具有给定值的第一个元素
int Update(ALinkList AL, const ElemType &item)
{
	int p = AL[0].next;
	while(p != 0)
	{
		if(AL[p].data == item)
		{
			AL[p].data = item;
			return 1;
		}
		else
			p = AL[p].next;
	}
	return 0;
}

//向单链表的末尾添加一个元素
void InsertRear(ALinkList AL, const ElemType &item)
{
	int newptr = AL[1].next;  //从空闲表中取出表头结点
	if(newptr == 0)
	{
		cerr<<"No empty node!"<<endl;
		exit(1);
	}
	AL[1].next = AL[newptr].next;   //使空闲表中第二个结点成为新的表头结点
	AL[newptr].data = item;
	AL[newptr].next = 0;
	int p = AL[0].next;
	while(AL[p].next != 0)
		p = AL[p].next;
	AL[p].next = newptr;
	/*在带有表头附加结点的循环单链表中，在表头和
	非表头的位置插入或删除结点的操作方法相同，无须区别*/
}

//向单链表的表头插入一个元素
void InsertFront(ALinkList AL,const ElemType &item)
{
	int newptr = AL[1].next;
	if(newptr == 0)
	{
		cerr<<"No empty node!"<<endl;
		exit(1);
	}
	AL[1].next = AL[newptr].next;
	AL[newptr].data = item;
	AL[newptr].next = AL[0].next;
	AL[0].next = newptr;
}

//向单链表中满足条件的位置插入一个元素
void Insert(ALinkList AL, const ElemType &item)
{
	int newptr = AL[1].next;
	if(newptr == 0)
	{
		cerr<<"No empty node!"<<endl;
		exit(1);
	}
	AL[1].next = AL[newptr].next;
	AL[newptr].data = item;
	//找出item的插入位置及前驱结点位置
	int ap = 0,cp = AL[0].next;
	while(cp != 0)
	{
		if(item < AL[cp].data)
			break;
		else
		{
			ap = cp;
			cp = AL[cp].next;
		}
	}
	//实现插入操作
	AL[newptr].next = cp;
	AL[ap].next = newptr;
}

//删除表头元素
ElemType DeleteFront(ALinkList AL)
{
	if(AL[0].next == 0)
	{
		cerr<<"Deleting from an empty list!"<<endl;
		exit(1);
	}
	int p = AL[0].next;
	AL[0].next = AL[p].next;
	//把删除的结点插入到空闲表的表头
	AL[p].next = AL[1].next;
	AL[1].next = p;
	return AL[p].data;
}

//从单链表中删除等于给定值的第一个元素
int Delete(ALinkList AL, const ElemType &item)
{
	if(AL[0].next == 0)
	{
		cerr<<"LinkList is empty!"<<endl;
		return 0;
	}
	//查找被删除的结点及前驱结点
	int ap = 0, cp = AL[0].next;
	while(cp != 0)
	{
		if(AL[cp].data == item)
			break;
		else
		{
			ap = cp;
			cp = AL[cp].next;
		}
	}
	if(cp == 0)
	{
		cerr<<"Deleted element is not exist"<<endl;
		return 0;
	}
	//从单链表中删除查找到的下标为cp的结点
	AL[ap].next = AL[cp].next;
	AL[cp].next = AL[1].next;
	AL[1].next = cp;
	return 1;
}

//利用单链表进行数据排序
void LinkSort(ElemType a[], int n)
{
	ALinkList b;
	InitList(b);
	int i= 0;
	for(int i = 0; i < n; i++)
	{
		Insert(b,a[i]);
	}
	int p = b[0].next;
	i = 0;
	while(p != 0)
	{
		a[i++] = b[p].data;
		p = b[p].next;
	}
	ClearList(b);
}

//把单链表数组存入到文件中
void WriteLinkList(ALinkList AL, char *fname)
{
	ofstream ofstr(fname);
	if(!ofstr)
	{
		cerr<<"File\ '"<<fname<<"\'"<<"no open!"<<endl;
		exit(1);
	}
	for(int i = 0; i < MaxSize; i++)
		ofstr.write((char*)(AL+i),sizeof(ALNode));
	ofstr.close();
}

//把文件内容读入到单链表数组中
void ReadLinkList(ALinkList AL, char *fname)
{
	ifstream ifstr(fname, ios::in|ios::_Nocreate);
	if(!ifstr)
	{
		cerr<<"File\ '"<<fname<<"\'"<<"not found!"<<endl;
		exit(1);
	}
	for(int i = 0; i < MaxSize; i++)
		ifstr.read((char*)(AL+i),sizeof(ALNode));
	
	ifstr.close();
}

.cpp文件

#include <iostream>
#include <stdlib.h>
#include <fstream>

using namespace std;

typedef int ElemType;

const int MaxSize = 50;

typedef struct ALNode
{
	ElemType data;
	int next;  //next域指向的是后继结点所在的下标
}ALinkList[MaxSize];

#include "LinearList.h"

int main()
{
	//建立从小到大顺序链式存储的单链表
	ALinkList a;
	InitList(a);
	for(int i = 0; i < 20; i++)
	{
		Insert(a,rand() % 100);
	}
	//按随机数产生顺序显示数据
	for(int i = 2; i < 22; i++)
		cout<<a[i].data<<" ";
	cout<<endl;
	//按随机数从小到大顺序显示数据
	TraverseList(a);
	//按随机数从小到大顺序显示数据和链接指针
	cout<<endl;
	int j = 0;
	int i = a[0].next;
	while(i != 0)
	{
		cout<<"("<<a[i].data<<","<<a[i].next<<")";
		if(++j % 7 == 0)
			cout<<endl;
		i = a[i].next;
	}
	cout<<endl;
	//把数组a写入文件中
	WriteLinkList(a,"ALINKLIST.dat");
	//把文件读人到数组a，显示出前5个最小数
	ReadLinkList(a,"ALinkList.dat");
	cout<<endl;
	for(i = 1; i <= 5; i++)
	{
		cout<<GetElem(a,i)<<" ";
	}
	cout<<endl;
	return 0;
}