求教一道单链表基本操作的题目！

[xgfancz]

谢谢大家，··

#include <iostream.h>
#include <iomanip.h>
#include <conio.h>
#include <stdio.h>
#include <process.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

//定义结点类型
struct Node{
int data;
Node *next;
};

Node Head; //头结点
Node *DLList; //头指针

void init(Node *DLList);
void display(Node *DLList);
void insert(Node *DLList);
void search(Node *DLList);
void del(Node *DLList);

void main()
{
char choice;

DLList=&Head; //使头指针指向头结点
Head.next=NULL;

while (1)
{
system("cls");
cout << "\n\n\n\n";
cout << "\t\t 单链表操作 \n";
cout << "\t\t======================================";
cout << "\n\n";
cout << "\t\t 1：初始化 \n";
cout << "\t\t 2：显示 \n";
cout << "\t\t 3：单个插入 \n";
cout << "\t\t 4：查找 \n";
cout << "\t\t 5：删除 \n";
cout << "\t\t 0：退出 \n";
cout << "\n";
cout << "\t\t请选择：" << flush;

choice = getch();
system("cls");

switch(choice)
{
case '1':
init(DLList);
break;
case '2':
display(DLList);
break;
case '3':
insert(DLList);
break;
case '4':
search(DLList);
break;
case '5':
del(DLList);
break;
case '0':
exit(0);
}
}
}

//公用的等待函数
void wait()
{
cout << "\n\n请按任意键继续" << flush;
getch();
}

//屏幕提示后，从键盘输入线性表长度和随机数种子，生成以DLList为头指针的指定长度的线性表
void init(Node *DLList)
{
int length;
Node *p,*q;
while (1)
{
cout << "输入元素个数（0－" << 10000 << "）：" << flush;
cin >> length;
if (length >= 0 && length <= 10000)
break;
cout << endl;
}

int i;
while (1)
{
cout << "输入随机数种子（0－32767）：" << flush;
cin >> i;
if (i >= 0 && i <= 32767)
break;
cout << endl;
}

//从线性表中删除并释放原有的结点，使其成为空表
p=DLList;
while (p->next!=NULL)
{
q=p->next;
p->next=q->next;
free(q);
}

srand(i); //指定随机数种子，相同的种子将产生相同的数据序列
rand();

//向线性表插入length个新结点
for (int j=1;j<=length;j++)
{
p=new Node;
p->next=DLList->next;
DLList->next=p;
p->data=rand() % 10000;
}
}

//在屏幕上依次显示以DLList为头指针的线性表中的全部元素和元素个数
//格式应便于观察
//如果需要指定输出的宽度，可以使用 cout << setw(W) << X ，其中 X 是输出的数值，W 是占据的列数
void display(Node *DLList)
{
}

//屏幕提示后，从键盘输入一个元素值，然后把这个新元素插到以DLList为头指针的线性表的末尾
void insert(Node *DLList)
{
}

//屏幕提示后，从键盘输入一个元素值，在以DLList为头指针的线性表中搜索这个元素
void search(Node *DLList)
{
}

//屏幕提示后，从键盘输入一个元素值，在以DLList为头指针的线性表中删除这个元素
//屏幕显示删除成功与否的信息
void del(Node *DLList)
{
}

[tanchao90]

#include"iostream.h"
#include"stdlib.h"
#include "linkedlist.cpp"

void out();
int DoMenu();
void Union(List<int> La,List<int> Lb,int c);
void Intersection(List<int> La,List<int> Lb,int c);
void Josephus(int n,int m);

void main(int argc, char* argv[])
{
int choice,lc;
List<int> L1,L2,*temp;
out();
int x;
int i;
while(1)
{
cout<<"请选择要操作的单链表："<<endl;
cout<<"1:对单链表L1进行操作"<<endl;
cout<<"2:对单链表L2进行操作"<<endl;
cout<<"3:求解约瑟夫问题"<<endl;
cin>>lc;
if(lc==1) //判断要操作那个顺序表
temp=&L1;
else
if(lc==2)
temp=&L2;
else
if (lc==3)
{
int n,m;
cout<<"输入约瑟夫问题游戏者人数："<<endl;
cin>>n;
cout<<"输入报数间隔："<<endl;
cin>>m;
Josephus(n,m);
continue ;
}
else
{
cout<<"操作错误，请重新操作！"<<endl;
continue ;
}
choice=DoMenu();
switch(choice)
{
case 1:
temp->input();
break;
case 2:
cout<<"请输入要插入的元素："<<endl;
cin>>x;
cout<<"请输入元素要插入的位置："<<endl;
cin>>i;
if(!temp->Insert(i,x))
cout<<"插入不成功！";
break;
case 3:
cout<<"请输入要删除元素的位置："<<endl;
cin>>i;
if(temp->Remove(i,x))
cout<<"元素"<<x<<"被删除！"<<endl;
else
cout<<"删除不成功。"<<endl;
break;
case 4:
cout<<"请输入单链表中要修改的元素的位置："<<endl;
cin>>i;
cout<<"请输入修改后的值："<<endl;
cin>>x;
if(temp->setData(i,x))
cout<<"修改成功！"<<endl;
else
cout<<"修改失败！"<<endl;
break ;
case 5:
cout<<"单链表的实际长度是："<<temp->length()<<endl;
break;
case 6:
cout<<"单链表中的元素是："<<endl;
temp->output();
break ;
case 7:
temp->sort();
break;
case 8:
Union(L1,L2,0);
break ;
case 9:
Intersection(L1,L2,0);
break ;
case 10:
Union(L1,L2,1);
break ;
case 11:
Intersection(L1,L2,1);
break ;
case 12:
temp->deletesame();
break ;
default:
cout<<"input ERROR"<<endl;
}
};
return ;
}


void out()
{
cout<<"********************************************************************************"<<endl;
cout<<"************************************ 单链表 ************************************"<<endl;
}


int DoMenu()
{
int selection;

cout<<endl;
cout<<"1. input"<<endl;
cout<<"2. Insert"<<endl;
cout<<"3. Remove"<<endl;
cout<<"4. setData"<<endl;
cout<<"5. Length"<<endl;
cout<<"6. output"<<endl;
cout<<"7. sort"<<endl;
cout<<"8. 求并集"<<endl;
cout<<"9. 求交集"<<endl;
cout<<"10. 有序单链表求并集"<<endl;
cout<<"11. 有序单链表求交集"<<endl;
cout<<"12. 删除单链表中元素相同的结点"<<endl;
cin>>selection;
return selection;
}


void Union(List<int> La,List<int> Lb,int c){
//合并单链表La与Lb，结果存于La，重复元素只留一个。
LinkNode<int> *pa=La.getHead();
LinkNode<int> *pa1=La.getHead();
LinkNode<int> *pb=Lb.getHead();
while (pb->link!=NULL)
{
while (pa->link!=NULL)
{
if (pb->link->data==pa->link->data)
break;
pa=pa->link;
}
if (pa->link==NULL)
{
LinkNode<int> *newNode=new LinkNode<int>(pb->link->data);
if (newNode==NULL)
{
cerr<<"存储分配错误！"<<endl;
exit(1);
}
newNode->link=La.getHead()->link;
La.getHead()->link=newNode;
}
pa1=pa1->link;
pa=pa1;
pb=pb->link;
}
if(c==1)
La.sort();
La.deletesame();
cout<<"两个单链表合并后的结果是："<<endl;
La.output();
}


void Intersection(List<int> La,List<int> Lb,int c){
//求单链表La与Lb中的共有元素，结果存于Lb中。
LinkNode<int> *pa=La.getHead();
LinkNode<int> *pb=Lb.getHead();
while (pb->link!=NULL)
{
while (pa->link!=NULL)
{
if (pb->link->data==pa->link->data)
break ;
pa=pa->link;
}
if (pa->link==NULL)
{
LinkNode<int> *del=pb->link;
pb->link=del->link;
delete del;
}
else
pb=pb->link;
pa=La.getHead();
}
if(c==1)
Lb.sort();
Lb.deletesame();
if(Lb.getHead()->link!=NULL)
{
cout<<"两个单链表求交后的结果是："<<endl;
Lb.output();
}
else
cout<<"两个单链表求交后的结果为空集！"<<endl;
}


void Josephus(int n,int m){ //约瑟夫问题
LinkNode<int> *first,*p;
for (int i=0;i<n;i++)
if(i==0)
{
first=p=new LinkNode<int>(i+1);
}
else
{
p->link=new LinkNode<int>(i+1);
p=p->link;
}
p->link=first;
first=NULL;
while (p->link!=p)
{
for (int j=1;j<m;j++)
p=p->link;
LinkNode<int> *dele=p->link;
p->link=dele->link;
cout<<"出列的人是："<<dele->data<<endl;
delete dele;
}
cout<<"最后结果是："<<p->link->data<<endl;
delete first;
delete p;
return ;
}

[tanchao90]

template <class T>
struct LinkNode{ //链表节点类的定义
T data;
LinkNode<T> *link;
LinkNode(LinkNode<T> * ptr=NULL ) //仅初始化指针成员的构造函数
{
link=ptr;
}
LinkNode(const T& item ,LinkNode<T> * ptr =NULL) //初始化数据和指针成员的构造函数
{
data=item;
link=ptr;
}
};

template<class T> //单链表类定义
class List{
protected:
LinkNode<T> * first;
public:
List(); //构造函数
List(const T& x); //构造函数
List(List<T> & L); //复制构造函数
~List(){ makeEmpty();} //析构函数
void makeEmpty(); //将链表置为空表
int length()const; //计算链表的长度
LinkNode<T> *getHead()const {return first;} //返回附加头结点的地址
LinkNode<T> *Search(T x); //搜索含数据x的元素
LinkNode<T> *locate(int i); //搜索第i个元素的的地址
bool getData(int i,T& x)const; //取出第i个元素的值
bool setData(int i,T& x); //用x修改第i个元素的值
bool Insert(int i,T x); //在第i个元素后插入x
bool Remove(int i,T& x); //删除第i个元素，x返回删除元素的值
bool IsEmpty()const; //判断表是否为空
// bool IsFull()const; //判断表是否为满
void sort(); //排序
void input(); //输入
void output(); //输出
void deletesame();
List<T> & operator=(List<T> & T); //重载函数：赋值
};


template<class T>
List<T>::List(){
first=new LinkNode<T>;
}


template<class T>
List<T>::List(const T& x){
first=new LinkNode<T>(x);
}


template<class T>
List<T>::List(List<T> & L){
T value;
LinkNode<T> * srcptr=L.getHead();
LinkNode<T> * destptr=first=new LinkNode<T>;
while (srcptr->link!=NULL) //逐个节点复制
{
value=srcptr->link->data;
destptr->link=new LinkNode<T>(value);
destptr=destptr->link;
srcptr=srcptr->link;
}
destptr->link=NULL;
}


template<class T>
void List<T>::makeEmpty(){
LinkNode<T> *q;
while (first->link!=NULL) //当链不空时，删去链中所有的节点
{
q=first->link;
first->link=q->link;
delete q;
}
}


template<class T>
int List<T>::length()const{
LinkNode<T> *p=first->link;
int count=0;
while (p!=NULL) //循环扫描，寻找链尾
{
p=p->link;
count++;
}
return count;
}


template<class T>
LinkNode<T> *List<T>::Search(T x){ //在表中搜索含数据x的结点，搜索成功时返回该结点的地址；否则返回NULL值。
LinkNode<T> * current=first->link;
while(current!=NULL)
if(current->data==x)
break;
else
current=current->link;
return current;
}


template<class T>
LinkNode<T> *List<T>::locate(int i){ //定位函数。返回第i个元素的地址。若i<0或i超出表中结点个数，则返回NULL
if(i<0)
return NULL;
LinkNode<T> *current =first;
int k=0;
while (current!=NULL&&k<i)
{
current=current->link;
k++;
}
return current;
}


template<class T>
bool List<T>::getData(int i,T& x)const{ //取出链表中第i个元素的值
if(i<=0)
return NULL;
LinkNode<T> *current =locate(i);
if(current==NULL)
return false;
else
{
x=current->data;
return true;
}
}


template<class T>
bool List<T>::setData(int i,T& x){ //给链表中第i个元素赋值x.
if(i<=0)
return false;
LinkNode<T> *current =locate(i);
if(current==NULL) //i值太大
return false;
else
current->data=x;
return true;
}


template<class T>
bool List<T>::Insert(int i,T x){ //将新元素x插入在链表中第i个结点之后。
LinkNode<T> *current=locate(i);
if(current==NULL)
return false;
LinkNode<T> *newNode=new LinkNode<T>(x);
if (newNode==NULL)
{
cerr<<"存储分配错误！"<<endl;
exit(1);
}
newNode->link=current->link;
current->link=newNode;
return true;
}


template<class T>
bool List<T>::Remove(int i,T& x){ //将链表中第i个元素删去，通过引用型参数x返回该元素的值。
LinkNode<T> *current=locate(i-1);
if(current==NULL||current->link==NULL)
return false;
LinkNode<T> *del =current->link;
current->link=del->link;
x=del->data;
delete del;
return true;
}


template<class T>
void List<T>::input(){ //输入函数：建立链表，并输入元素
LinkNode<T> *newNode;
T val;
cout<<"请输入要输入元素的个数："<<endl;
int count=0;
cin>>count;
makeEmpty();
for (int i=1;i<=count;i++)
{
cout<<"请输入第"<<i<<"个元素:"<<endl;
cin>>val;
newNode=new LinkNode<T>(val);
if (newNode==NULL)
{
cerr<<"存储分配错误！"<<endl;
exit(1);
}
newNode->link=first->link;
first->link=newNode;
}
}


template<class T>
void List<T>::output(){ //单链表的输出函数。将链表中所有元素按逻辑顺序输出到屏幕上。
LinkNode<T> *current=first->link;
while (current!=NULL)
{
cout<<current->data<<endl;
current=current->link;
}
}


template<class T>
void List<T>::sort(){ //链表中元素从小到大排序。
LinkNode<T> *p1=first;
LinkNode<T> *p2;
while(p1->link!=NULL)
{
p2=p1->link;
while(p2->link!=NULL)
{
if(p1->link->data > p2->link->data)
{
T temp=p2->link->data;
p2->link->data=p1->link->data;
p1->link->data=temp;
}
p2=p2->link;
}
p1=p1->link;
}
}


template<class T>
void List<T>::deletesame(){ //删除相同的结点
LinkNode<T> *p=first;
LinkNode<T> *p1;
while (p->link!=NULL)
{
p1=p->link;
while (p1->link!=NULL)
{
if (p->link->data==p1->link->data)
{
LinkNode<T> *del;
del=p1->link;
p1->link=del->link;
delete del;
continue ;
}
p1=p1->link;
}
p=p->link;
}
}


template<class T>
List<T> &List<T>::operator =(List<T> &L){ //重载函数：赋值操作，形如A=B，其中A是调用次操作的List对象，B是与参数表中的引用型参数L结合的实参
T value;
LinkNode<T> * srcptr=L.getHead();
LinkNode<T> * destptr=first=new LinkNode<T>;
while (srcptr->link!=NULL) //逐个结点复制
{
value=srcptr->link->data;
destptr->link=new LinkNode<T>(value);
destptr=destptr->link;
srcptr=srcptr->link;
}
destptr->link=NULL;
return *this; //返回操作对象地址
}


template<class T>
bool List<T>::IsEmpty()const{ //判断表是否为空
return first->link==NULL?true:false;
}