c 语言单链表,c 语言单链表

http://blog.csdn.net/caojunhao123/article/details/11750517

/这是个单链表的菜单选择操作系统，能够模拟单链表的各种基本操作。

//很早以前在网上发现的，已经不知道作者信息了，仅供参考。

#include

#include

using namespace std;

typedef int ElemType;

//链表结构体定义

typedef struct LNode

{

ElemType data;

struct LNode *next;

}LNode, *LinkList;

//全局变量指针

LNode *head = new LNode;

/*

以下是各种功能函数的原型，带有相应的参数

*/

//创建函数，创建一个新的链表

void CreatList( LNode *L )

{

int i, n;

LNode *s, *p;

p = L;

cout<

cin>>n;

for( i = 1; i <= n; i++ )

{

s = new LNode;

cout<

cin>>s->data;

p->next = s;

p = s;

}

p->next = NULL;

}

//显示函数，将链表的各个元素输出

void OutList( LNode *L )

{

LNode *q, *head;

head = L;

q = head->next;

if( q== NULL )

cout<

else

{

while( q != NULL )

{

cout<data <

q = q->next;

}

}

cout<

}

//查找函数，在L链表中查找第i个元素

ElemType GetElem( LNode *L, int i )

{

int j = 1;

LNode *p;

p = L->next;

while( p && j < i )

{

p = p->next;

j++;

}

if( !p || j > i )

return -1;

else

return ( p->data );

}

//查找函数，查找指定元素

ElemType FindElem( LNode *L, ElemType e )

{

int j = 1;

LNode *p;

p = L->next;

while( p )

{

if( p->data == e )

return j;

else

{

p = p->next;

j++;

}

}

return -1;

}

//插入函数，将元素e插入链表L的第i个位置

void InsertList( LNode *L, int i, ElemType e )

{

LNode *p, *s;

int j = 1;

p = L;

while( p != NULL && j < i )

{

p = p->next;

j++;

}

if( p == NULL || j > i )

{

cout<

}

else

{

s = new LNode;

s->data = e;

s->next = p->next;

p->next = s;

}

}

//删除函数，删除链表L的第i个元素

ElemType DeleteList( LNode *L, int i )

{

LNode *p, *q;

int j = 0;

ElemType e;

p = L;

while( p->next != NULL && j < i - 1 )

{

p= p->next;

j++;

}

if( p->next == NULL || j > i - 1 )

cout<

else

{

q = p->next;

e = q->data;

p->next = q->next;

delete ( q );

return  e ;

}

return 0;

}

//删除函数，将指定的元素x删除

void ListDelete( LNode *L, ElemType x )

{

LNode *p, *q;

p = L;

while( p->next && p->next->data != x )

p = p->next;

if( !p->next )

cout<

else

{

q = p->next;

p->next = q->next;

delete q;

}

}

//链表合并函数，将两个链表合并，并得到一个新的链表

LNode *MergeList( LNode *La, LNode *Lb )

{

LNode *Lc, *pa, *pb, *pc;

Lc = La;

pc = La;

pa = La->next;

pb = Lb->next;

while( pa != NULL && pb != NULL )

{

if( pa->data < pb->data )

{

pc->next = pa;

pc = pa;

pa = pa->next;

}

else if( pa->data > pb->data )

{

pc->next = pb;

pc = pb;

pb = pb->next;

}

/*此次判断的是如果两个元素相等，只取其中一个，并将另一个删除

有点类似求并集*/

else

{

pc->next = pa;

pc = pa;

pa = pa->next;

pb = pb->next;

}

}

if( pa != NULL )

pc->next = pa;

else

pc->next = pb;

delete Lb;

return Lc;

}

//升序排列

void UpSort( LNode *L )

{

LNode *p = L->next, *q, *r;

if( p != NULL )

{

r = p->next;

p->next = NULL;

p = r;

while( p != NULL )

{

r = p->next;

q = L;

while( q->next != NULL && q->next->data < p->data )

q = q->next;

p->next = q->next;

q->next = p;

p = r;

}

}

OutList( L );

}

//降序排列

void DownSort(LNode *L)

{

LNode *p = L->next, *q, *r;

if( p != NULL )

{

r = p->next;

p->next = NULL;

p = r;

while( p != NULL )

{

r = p->next;

q = L;

while( q->next != NULL && q->next->data > p->data )

q = q->next;

p->next = q->next;

q->next = p;

p = r;

}

}

OutList( L );

}

//逆置函数

void rev_link( LNode *list )

{

LNode *p,*q,*r;

p = list->next;

if( p == NULL )

return;

q = p->next;

if( q == NULL )

return;

r = q->next;

while( r!= NULL )

{

q->next = p;

p = q;

q = r;

r = r->next;

}

q->next = p;

list->next->next = NULL;

list->next = q;

}

//逆置函数

void reverse( LNode *L )

{

LNode  *p, *q;

p = L->next;

L->next = NULL;

while (p)

{

q=p;

p=p->next;

q->next=L->next;

L->next=q;

}

}

//使用递归的逆置

void reverseList( LNode *L )

{

if( L != NULL )

{

reverseList( L->next );

cout<data<

}

}

/*

以下是 choice() 函数中所用到的各种函数定义，为了方便，

特意专门列出，便于进行变量的设置和存取

*/

//插入函数

void Inser()

{

cout<

int loa;

ElemType e;

cout<

cin>>loa>>e;

InsertList( head, loa, e );

cout<

OutList( head );

}

//删除函数，可以进行两种选择，删除指定位置和删除指定元素

void del()

{

cout<

int cho;

cout<

cin>>cho;

if( cho == 1 )

{

int loa;

cout<

cin>>loa;

cout<

cout<

OutList( head );

}

else if( cho == 2 )

{

int elem;

cout<

cin>>elem;

ListDelete( head, elem );

cout<

OutList( head );

}

else

{

cout<

del();

}

}

//查找函数，可以进行两种选择，查找指定元素和查找指定位置

void Find()

{

cout<

int cho;

cout<

cin>>cho;

if( cho == 1 )

{

int loa;

cout<

cin>>loa;

if( GetElem( head, loa ) == -1)

cout<

else

cout<

}

else if( cho == 2 )

{

int elem;

cout<

cin>>elem;

if( FindElem( head, elem ) == -1)

cout<

else

cout<

}

else

{

cout<

Find();

}

}

//获取链表长度函数

void GetLength( LNode *L )

{

cout<

LNode *p;

int length = 0;

p = L->next;

while( p )

{

p = p->next;

length++;

}

cout<

}

//链表合并函数，可以进行链表大小的设置

void Merge()

{

cout<

LNode *a, *b;

a = new LNode;

b = new LNode;

CreatList( a );

CreatList( b );

cout<

OutList( a );

cout<

OutList( b );

cout<

OutList( MergeList( a, b ));

}

//特定次序排列

void Sort()

{

int cho;

cout<

cout<

cout<

cin>>cho;

switch( cho )

{

case 1:cout<

UpSort( head );

cout<

OutList( head );

break;

case 2:cout<

DownSort( head );

cout<

OutList( head );

break;

default:

cout<

break;

}

}

//逆置函数

void Reverse()

{

cout<

//reverse( head );

//rev_link( head );

reverseList( head->next );

}

//链表创建函数

void creat()

{

cout<

CreatList( head );

cout<

OutList( head );

}

//链表显示函数

void display()

{

cout<

OutList( head );

}

//显示当前时间

void currentTime()

{

time_t   tim=time( 0 );

cout<

}

//欢迎菜单

void welcome()

{

cout<

cout<

cout<

cout<

cout<

cout<

cout<

cout<

cout<

cout<

cout<

cout<

cout<

cout<

cout<

cout<

}

//功能选择函数

void choice()

{

cout<

cout<

cout<

cout<

cout<

int cho;

cin>>cho;

do

{

switch( cho )

{

case 0:break;

case 1:creat();break;

case 2:Inser();break;

case 3:del();break;

case 4:display();break;

case 5:Find();break;

case 6:GetLength( head );break;

case 7:Merge();break;

case 8:Reverse();break;

case 9:Sort( );break;

case 10:system("cls");break;

default:break;

}

cout<

cout<

cout<

cout<

cin>>cho;

}while( cho != 0 );

}

/*主函数，为了使函数简单明了，特意将所用到的各种函数都

封装到了choice()函数中，便于调用

*/

void main()

{

welcome();

choice();

}

//这是在一次实验中的程序，功能还比较完善，供参考。