已知带头结点的动态单链表L中的结点是按整数值递增排序的,编写算法将值为x的结点插入到表L中,使L仍然有序

//系统功能:1、已知带头结点的动态单链表L中的结点是按整数值递增排序的，编写算法将值为x的结点插入到表L中，使L仍然有序。
// 2、设计算法，逆置带头结点的动态链表L。要求利用原表的结点空间，并要求用尽可能少的时间完成。
// 3、假设有两个按元素值递增有序的线性表A和B，均以单链表作存储结构，试编写算法将A表和B表归并成一个按元素值递减有序的线性表C，并要求利用原表的空间存放C。
// 4、假设在长度大于1的单循环链表中，既无头结点也无头指针。s为指向某个结点的指针，编写算法删除结点*s的直接前驱结点。
// 5、已知由单链表表示的线性表中，含有三类字符的数据元素（如：字母、数字和其它字符），设计算法构造三个以循环链表示的线性表，使每一个表中只含同一类的字符，且利用原表中的结点空间作为这三个表的空间。（头结点可以另辟空间）
// 6、有一双链表，每个结点中除有prior、data和next域外，还有一访问频度域freq，在链表被启用前，其值均初始化为零。每当在链表上进行一次LOCATE(L,x)运算，元素值为x的结点中freq域的值增1，并使此链表中结点保持按freq递减的顺序排列，以便使频繁访问的结点总是靠近表头。设计满足上述要求的LOCATE算法并加以测试。

#include
#include
#include
#include
using namespace std;

typedef int Status;
typedef int ElemType;
typedef char ElemType1[100];

typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;

typedef struct LNode1{
ElemType1 data; //char data[100]
struct LNode1 *prior;
struct LNode1 *next;
int freq;
}LNode1,*LinkList1;
//**********************************初始化********9/17*************************************************
Status InitList_L(LinkList &L){
L=new LNode;
L->next=NULL;
return 1;
}
Status InitList_L1(LinkList1 &L){
L=new LNode1;
L->next=NULL;
return 1;
}
//*********************************求表长**********9/17**************************************************
Status ListLength_L(LinkList L){
LinkList p;
p=L->next; //p指向第一个结点
int i=0;
while(p){
i++;
p=p->next; }
return i;
}

//**********************************创建单链表*********9/17*************************************************
void CreateList_L(LinkList &L,int &n){
int i;
L=new LNode;
LinkList p;
L->next=NULL; //先建立一个带头结点的单链表
for( i=n;i>0;i--){
p=new LNode;
cin>>p->data;
p->next=L->next;L->next=p; //插入到表头
}
cout<<"链表中元素排列顺序为"<

while(p)
{
cout<data<<" ";
p=p->next;
}
cout<}
void CreateList_L1(LinkList1 &L,int &n){
int i;
L=new LNode1;
LinkList1 p;
L->next=NULL; //先建立一个带头结点的单链表
for( i=n;i>0;i--){
p=new LNode1;
cin>>p->data;
p->next=L->next;L->next=p; //插入到表头
}
cout<<"链表中元素排列顺序为"<while(p)
{
cout<data<<" ";
p=p->next;
}
cout<}

//**********************************插入********9/21~9/25****************************************************
//因为有头结点，所以不用分类讨论，也不用引入两个指针变量
void ListIsert_L(LinkList &L,int &n,ElemType e)
{
LinkList p=L,s=L;
s=new LNode;
s->next=NULL;
s->data=e;
if(L==NULL)
{
L=s;
}
else
{
while(p->next!=NULL&&p->next->data{
p=p->next;
}
s->next=p->next;
p->next=s;
}
n++;
p=L->next;
cout<<"插入元素后递增顺序为:"<for(int i=1;i<=n;i++)
{

cout<data<<" ";
p=p->next;
}
}

//*********************************逆置****9/30*********************************************************
void nizhi(LinkList &L,int n)
{
LinkList p=L->next,t;
if(L->next==NULL)
{
cout<<"无元素"<}
else{
L->next=NULL;
while(p)
{
t=p;
p=p->next;
t->next=L->next;
L->next=t;

}
p=L->next;
while(p)
{
cout<data<<" ";
p=p->next;
}
}
}
//********************************合并*********10/2************************************************
//思想：合并后逆置
//想法：合并时采用前插法，但是当只剩一个链表时，就要一个元素一个元素插
void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc)
{
LinkList pa=La->next;
LinkList pb=Lb->next;
LinkList pc=Lc=La; //用La的头结点作为Lc的头结点
int n;
while(pa && pb)
{
if(pa->data<=pb->data)
{
pc->next=pa;
pc=pa;
pa=pa->next;
}
else
{
pc->next=pb;
pc=pb;
pb=pb->next;
}
}
pc->next=pa?pa:pb; //插入剩余段
n=ListLength_L(Lc);
nizhi(Lc,n);
delete Lb; //释放Lb的头结点
}

//**********************************创建循环链表*********10/6*************************************************
Status CreateList_C(LinkList1 &l,int n)
{
int i;
LinkList1 t,p;
l=new LNode1;
t=l;
cin>>t->data;
t->next=NULL;
for (i=2;i{
p=new LNode1;
cin>>p->data;
t->next=p;
t=p;
}
t->next=l;
return 1;
}
//******************************删除单循环链表中*s的直接前驱结点**10/5*****************************************
void deletes()
{
LinkList1 s;
LinkList1 p,q;
int n,m;
cout<<"请输入无头结点无头指针的单循环链表中元素个数

："<cin>>n;
cout<<"请输入无头结点无头指针的单循环链表中元素："<CreateList_C(s,n);
cout<<"请输入您要删除第几个节点的前驱结点(第一个输入的数算作第一个结点)"<cin>>m;
m--;
while(m--)
s=s->next;
p=s;
while(p->next->next!=s)
{
p=p->next;
}
q=p->next;
p->next=s;
delete q ;
for(int i=1;i<=n-1;i++)
{
cout<data<<" ";
p=p->next;
}
cout<}

//********************************构造三个以循环链表示的线性表****10/6*************************************
void DivideList( LinkList1 &L, LinkList1 A, LinkList1 B, LinkList1 C)
{
LinkList1 p=L->next, q;
LinkList1 a=A,b=B,c=C;
int a1=0,b1=0,c1=0;
while ( p )
{
if (strcmp( p->data,"a")>=0 &&strcmp(p->data,"z")<=0||strcmp( p->data,"A")>=0 &&strcmp(p->data,"Z")<=0)
{
a1++;
q=p; //保存字母结点位置
p=p->next;
a->next=q;
q->next=A->next;// 形成循环链表
a=a->next;
}
else if(strcmp( p->data,"0")>=0 &&strcmp( p->data,"9")<=0)
{
b1++;
q=p;
p=p->next;
b->next=q;
q->next=B->next;
b=b->next;
}
else
{
c1++;
q=p;
p=p->next;
c->next=q;
q->next=C->next;
c=c->next;
}
}
//a=A->next;b=B->next;c=C->next;
cout<<"分离出含字母的链表部分："<while(a1--)//一开始写成没用a1计数，while（a）当然死循环了，因为它是循环链表啊！
{
cout<data<<" ";
a=a->next;
}
cout<cout<<"分离出含数字的链表部分："<while(b1--)
{
cout<data<<" ";
b=b->next;
}
cout<cout<<"分离出含除字母与数字外的链表的其他部分："<while(c1--)
{
cout<data<<" ";
c=c->next;
}
cout<}
//*********************************双向链表的初始化*********10/6********************************************
Status InitList_D(LinkList1 &L){
L=new LNode1;
L->next=L->prior=NULL;
return 1;
}
//*********************************创建双链表***************10/6~10/7************************************************
void CreateList_D(LinkList1 &L,int &n)
{
LinkList1 p,q;
L = new LNode1;
p = L;
for(int i = 1;i <=n;i++) {
q = new LNode1;
cin >> q->data;
q->freq =1;
q->next=NULL;
p->next = q;
q->prior = p;
p = q;
}


}
//*********************************访问频度排序***********10/6~10/7*********************************************
void LOCATE(LinkList1 &L,ElemType1 x,int n)
{
LinkList1 p=L->next,q=L->next;

while(p)
{
if(strcmp(p->data,x)!=0)
p=p->next;
else
{
p->freq++;
//cout<freq<break;
}
}
while(q)
{

if(q->freq > p->freq)
{
q=q->next;
}
else if(p==q)

break;
else
{
p->prior->next=p->next;//摘下
if(p->next)
p->next->prior=p->prior;
p->prior=q->prior;//插入
q->prior->next=p;
p->next=q;
q->prior=p;
break;
}
}
cout<<"按访问频度由大到小排序后链表中元素顺序为"<p=L->next;
for( int i=1;i<=n;i++)
{
cout<data<<" ";
p=p->next;
}
}
//********************************菜单****9/30*********************************************************
void caidan()
{
printf("\n请选择菜单:\n");
printf("\t\t\t1 创建链表\n");
printf("\t\t\t2 插入元素(在1创建的链表中插入)\n");
printf("\t\t\t3 逆置链表\n");
printf("\t\t\t4 合并链表\n");
printf("\t\t\t5 删除前驱结点\n");
printf("\t\t\t6 分离链表中相同属性元素\n");
printf("\t\t\t7 访问频度排序\n");
printf("\t\t\t0 退出系统\n");
}
//*********************************主函数***********************************************************

int main()
{
LinkList head=NULL;
LinkList head1=NULL;
LinkList head2=NULL;
LinkList1 head3=NULL;
LinkList1 A=NULL,B=NULL,C=NULL;
int n,m,k;
ElemType e;
ElemType1 x;
caidan();
do{
scanf("%d",&m);
switch(m)
{
case 1:
system("cls");
cout<<"请输入链表中元素个数:"<cin>>n;
InitList_L(head);
cout<<"请按递减顺序依次输入元素:"<CreateList_L(head, n);

break;
case 2:
system("cls");
cout<<"请输入您要插入的元素:"<cin>>e;
ListIsert_L(head,n,e); break;
case 3:
system("cls");
cout<<"逆置后链表中元素为："<nizhi(head,n); break;
case 4:
system("cls");
cout<<"请输入a链表中元素个数:"<cin>>n;
InitList_L(head1);
cout<<"请按递减顺序依次输入元素:"<CreateList_L(head1, n);
//system("cls");
cout<<"请输入b链表中元素个数:"<cin>>n;
InitList_L(head2);
cout<<"请按递减顺序依次输入元素:"<CreateList_L(head2, n);
cout<<"合并后链表中按递减顺序存储的元素为："<MergeList_L(head1,head2,head);
break;
case 5:
system("cls");
deletes();
break;
case 6:
system("cls");
InitList_L1(head3);
InitList_L1(A);
InitList_L1(B);
InitList_L1(C);
cout<<"请输入链表中元素个数:"<cin>>n;
cout<<"请输入元素:"<CreateList_L1(head3, n);
DivideList( head3, A,B,C); break;
case 7:
system("cls");
InitList_D(head3);
cout<<"

请输入链表元素个数"<cin>>n;
cout<<"请输入链表元素"<CreateList_D(head3, n);
while(1)
{
cout<<"请输入您要访问的元素"<cin>>x;
LOCATE(head3,x,n);
cout<<"是否继续访问："<cout<<"1 继续"<cout<<"2 不继续\n 请选择："<cin>>k;
if(k==2) break;
} break;
case 0:
printf("谢谢使用本系统！"); break;
default:
printf("没有此菜单选项!\n");
}
if(m!=0)
{
caidan();
printf("请继续选择菜单选项：");
}

}while(m!=0);



return 0;
}