链表

//------------------------------------声明文件xyz.h-------------------------------------------------------
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

#define TRUE 1
#define FALSE 0
#define ERROR 0
#define OVERFLOW 0
#define OK 1
#define NULL 0

typedef int Status;
typedef int ElemType;

struct LNode
{
 ElemType data;
 LNode *next;
};

typedef LNode *LinkList;

Status CreatList(LinkList &L);//初始化一个链表
Status DestroyList(LinkList &L);//销假链表
Status ClearList(LinkList L);//清空链表
Status ListEmpty(LinkList L);//判断链表是否为空
int ListLength(LinkList L);//返回表的长度
Status GetElem(LinkList L,int i,ElemType &e);//返回第i个元素的值
int LocateElem(LinkList L,ElemType e,Status(*compare)(ElemType));//返回L中第1个与e满足关系compare()的数据元素的位序
Status ListInsert(LinkList L,int i,ElemType e);//在带头结点的单链表中第i个位置之前插入元素e
Status ListDelete(LinkList L,int i,ElemType &e);//在带头结点的单链表中，删除第1个元素，用e返回其值勤
Status compare(ElemType,ElemType);
void print(ElemType e);
void Listprint(LinkList L);
void End_main();

//------------------------------------实现文件Link.cpp-------------------------------------------------------
#include<stdio.h>
#include"xyz.h"

/************************************************************************/
/* 函数名：CreatList                                                   */
/* 函数功能：创建一个空的线性链表                                       */
/* 函数形参：LinkList &L 链表                                            */
/* 返回值：OK--销毁成功，ERROR---创建失败, OVERFLOW---申请空间失败  */      
/* 作者：Ｓｕｎｎｙ　             */
/************************************************************************/

Status CreatList(LinkList &L)
{

 L = (LinkList)malloc(sizeof(LNode));/*产生头结点,并使L指向此头结点*/

 if(!L)
  exit(OVERFLOW);

 L->next = NULL;
 return OK; 
}

/************************************************************************/
/* 函数名：DestroyList                                                  */
/* 函数功能：销毁已经创建的链表                                       */
/* 函数形参：LinkList &L 链表                                           */
/* 返回值：OK--销毁成功，ERROR---创建失败, OVERFLOW---申请空间失败  */      
/* 作者：Ｓｕｎｎｙ　             */
/************************************************************************/

Status DestroyList(LinkList &L)
{ 
 LNode *p = L;
 LNode *_temp = NULL;
 //空则结束。
 if (ListEmpty( p))
 {
  return OK;
 }
 while (p)
 {
  _temp = p;
  p=p->next;
  free(_temp);
 }
 L = NULL;
 return OK;

}

 

/************************************************************************/
/* 函数名：ClearList                                                    */
/* 函数功能：将存储数据的链表清空                                       */
/* 函数形参：LinkList L 链表                                            */
/* 返回值：OK--销毁成功，ERROR---创建失败, OVERFLOW---申请空间失败  */      
/* 作者：Ｓｕｎｎｙ　             */
/************************************************************************/

Status ClearList(LinkList L)
{
 LinkList p = L->next;
 L->next = NULL;
 DestroyList(p);   /*销毁P所指向的单链表*/
 return OK;

}

/************************************************************************/
/* 函数名：ListEmpty                                                    */
/* 函数功能：判断链表是否为空                                         */
/* 函数形参：LinkList L 链表                                            */
/* 返回值：表为空则返回TRUE，否则返回FALSE        */      
/* 作者：Ｓｕｎｎｙ　             */
/************************************************************************/

Status ListEmpty(LinkList L)
{
 LinkList p=L;
 if(!p || NULL == p->next)
 {
  printf("链表为空！需要重新建立新链表！");
  return FALSE;
 }
 else
  return TRUE;
}

/************************************************************************/
/* 函数名：ListLength                                                   */
/* 函数功能：获取链表的元素个数                                         */
/* 函数形参：LinkList L 链表                                            */
/* 返回值：i 返回表中的元素的个数                                   */      
/* 作者：Ｓｕｎｎｙ　             */
/************************************************************************/

int ListLength(LinkList L)
{
 int i = 0;
 LinkList p = L->next;    //P指向第一个结点
 
 while(p)       //未到表尾
 {
  i++;
  p = p->next;
 }
 return i;
}

/************************************************************************/
/* 函数名：GetElem(                                                     */
/* 函数功能：获取链表中第i个元素（该元素存在的时），将其值赋给e         */
/* 函数形参：LinkList L 链表 ,i 第i个节点，e存储获得节点数据            */
/* 返回值：OK--成功，ERROR---失败, OVERFLOW---申请空间失败        */      
/* 作者：Ｓｕｎｎｙ　             */
/************************************************************************/

Status GetElem(LinkList L,int i,ElemType &e)
{
 int j = 1;      //计数器初值为0
 LinkList p = L->next;   //p指向第一个结点

 while(p && (j < i))    //顺指针向后查找，直到找到p指向第i个结点
 {
  j++;
  p = p->next;
 }

 if(!p || (j > i))
  return ERROR;
 e = p->data;

 return OK;
}

/************************************************************************/
/* 函数名：LocatElem                                                   */
/* 函数功能：返回表中第1个与e满足关系compare()的数据关系的位序         */
/* 函数形参：LinkList L 链表                                            */
/* 返回值：OK--销毁成功，ERROR---创建失败, OVERFLOW---申请空间失败  */      
/* 作者：Ｓｕｎｎｙ　             */
/************************************************************************/

int LocatElem(LinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
{
 int i = 0;     //计数器初值为0
 LinkList p = L->next;
 
 while(p)     //未到表尾
 {
  i++;

 if(compare(p->data, e))  //找到这样的元素
  return i;    //返回其位序
 p = p->next;
 }
 return 0;
}

 

/************************************************************************/
/* 函数名：ListInsert                                                   */
/* 函数功能：删除链表中元素                                             */
/* 函数形参：LinkList L 链表 ，i 第i个元素 ，e为被插入节点数据         */
/* 返回值：OK--销毁成功，ERROR---创建失败, OVERFLOW---申请空间失败  */     
/* 作者：Ｓｕｎｎｙ　             */
/************************************************************************/

Status ListInsert(LinkList L, int i, ElemType e)
{

 int j = 0;       //计数器初值为0
 LinkList s, p = L;     //p指向头结点
 
 while(p && (j > (i-1)) )   //寻找第i个结点
 {
  j++;
  p = p->next;
 }

 if( !p ||(j > (i-1)))
  return ERROR;
 s = (LinkList) malloc ( sizeof (LNode)); /*生成新的结点*/
 s->data = e;
 s->next = p->next;      /*新结点指向原第i个结点*/
 p->next = s;       /*原第i-1个结点指向新结点*/
 return OK;
}

/************************************************************************/
/* 函数名：ListDelete                                                   */
/* 函数功能：删除链表中元素                                             */
/* 函数形参：LinkList L 链表 ，i 第i个元素 ，e为被删删除节点数据   */
/* 返回值：返回删除节点数据值           */      
/* 作者：Ｓｕｎｎｙ　             */
/************************************************************************/

Status ListDelete(LinkList L, int i, ElemType &e)
{

 int j = 0;       /*计数器初值为0*/
 LinkList q, p = L;     /*p指向头结点*/
 
 while(p->next && (j > (i-1)) )  /*寻找第i个结点，并用p指向其前驱*/
 {
  j++;
  p = p->next;
 }
 if((!p->next) || (j > (i-1)) )
  return ERROR;
 q = p->next;
 p->next = q->next;
 e = q->data;
 free(q);
 return OK;
}

/************************************************************************/
/* 函数名：print                                                        */
/* 函数功能：输出数据元素                                               */
/* 函数形参：ElemType e 数据元素                                        */
/* 返回值：空               */      
/* 作者：Ｓｕｎｎｙ　             */
/************************************************************************/

void print(ElemType e)
{
 printf( "%2d", e);
}

/************************************************************************/
/* 函数名：Listprint                                                    */
/* 函数功能：打印输出单链表                                     */
/* 函数形参：LinkList L 链表                                            */
/* 返回值：空               */      
/* 作者：Ｓｕｎｎｙ　             */
/************************************************************************/

void Listprint( LinkList L)
{ 
 LinkList p = L->next;

 while( p )
 { 
  printf( "%2d", p->data) ;
  p = p->next;
 }
 printf( "/n");
}

/************************************************************************/
/* 函数名：compare                                                      */
/* 函数功能：比较两个数据是否                                     */
/* 函数形参：LinkList L 链表                                            */
/* 返回值：空               */      
/* 作者：Ｓｕｎｎｙ　             */
/************************************************************************/

Status compare(ElemType x, ElemType y)
{
 return x == y;
}

/************************************************************************/
/* 函数名：End_main                                                  */
/* 函数功能：                            */
/* 函数形参：                             */
///* 返回值：  */         */     
/* 作者：Ｓｕｎｎｙ　             */
/************************************************************************/
void End_main()
{
 fflush(stdin);//清理缓存
 printf("/n/nPress any key to continue....");
 getchar();
}

//------------------------------------主函数Link_main.cpp-------------------------------------------------------

#include<stdio.h>
#include"xyz.h"

void main()
{ 
 LinkList L;
 int i, k, j;
 int Elements=0;
 int LinkList_length=0;
 int Number=0;
 int Operation=0;
 char Data_type=0;
 char exit='N';

 do
 {
  system("CLS");
  printf ("/t/t****************链表实验操作**************************/n");
  printf("/t/t*           0.创建一个顺序表    .........(0)           */n");
  printf("/t/t*           1.初始化一个顺序表  .........(1)           */n");
  printf("/t/t*           2.在顺序表中查找元表.........(2)           */n");
  printf("/t/t*           3.在顺序表中插入元表.........(3)           */n");
  printf("/t/t*           4.在顺序表中删除元表.........(4)           */n");
  printf("/t/t*           5.输出顺序链表元素..........（5)           */n");
  printf("/t/t*           6.销毁顺序链表..............（6）          */n");
  printf("/t/t*           7.清空链表...................(7)           */n");
  printf("/t/t*           8.退出.......................(8)           */n");
  printf("/t/t*******************************************************/n");
  fflush(stdin);
  printf("/n请选择操作代码：");
  //scanf("%[ ]", &Operation);
  Operation=getchar();

  fflush(stdin);
  switch(Operation)
  {
  case '0':
   CreatList(L);     /*创建链表*/   
   k=ListEmpty(L);
   printf("/n链表L是否为空表? 是(k=1）/ 否(k=0): k = %2d",k);
   printf("/n 链表创建成功！/n");
   End_main();
   break;

  case '1':
   printf("请输入你想要存入链表的数据个数：");
   scanf("%2d",&Number);

   for(i=1;i<=Number;i++)
   {
    ListInsert(L,1,i);
   }

   LinkList_length=ListLength(L);
   printf("链表为L=2%d/n ",LinkList_length);
   End_main();
   break;

  case '2':
   printf("请输入所要查找的元素：");
   scanf("%2d",&Elements);

   //LocatElem(L, Elements,Status(*compare)(ElemType,ElemType))
   //print("")

   End_main();
   break;

  case '3':
   printf("请输入需要插入的元素：");
   scanf("%2d",&Elements);

   LinkList_length=ListLength(L);
   ListInsert(L,LinkList_length,Elements);//在L的表尾插入j

   printf("重新插入元素之后表变为:");
   Listprint(L);

   system("pause");
   End_main();
   break;

  case '4':
   printf("请输入需要删除的元素：");
   scanf("%2d",&Elements);
   k=ListDelete(L,3,Elements);

   if(k==ERROR)
   {
    printf("删除不成功");
   }
   else
   {
    printf("删除元素成功，其值为2%d/n", Elements);
   }

   system("pause");
   End_main();
   break;

  case '5':
   printf("/n输出顺序链表:");
   Listprint( L);
   printf("/n");
   End_main();
   break;

  case '6':
   DestroyList(L);
   printf("/n已经成功销毁顺序链表！");
   End_main();

   break;

  case '7':
   ClearList(L);
   printf("表清空后长度为2%d",ListLength(L));
   Listprint(L);
   End_main();
   break;

  case '8':
   printf("/n您是否真的要退出程序(Y/N):");
   End_main();
   exit=getchar();
   break;

  default:
   printf("/n无效输入，请重新选择...:"); 
   End_main();
   break; 

  }

 }while(exit!='y'&&exit!='Y');

}