数据结构实验之图书馆借书线性表的顺序和链式存取结构的应用

/*
  Name: sqlist.h
  Copyright: 
  Author: 
  Date: 21-03-05 20:21
  Description: 
*/

#ifndef SQLIST_H_INCLUDED
#define SQLIST_H_INCLUDED

#include "ds.h" //for Status,OK ...

#ifndef ElemType
#define ElemType int /* 数据元素类型默认为 int */
#define ELEMTYPE_TAG
#endif

/**********************************************************
*  顺序表的存储结构定义 
***********************************************************/
#define LIST_INIT_SIZE 100 /* 存储空间初始分配容量 */
typedef struct {
    ElemType elem[LIST_INIT_SIZE];    //存放元素的数组
    int length;        //当前长度 
} SqList;

/**********************************************************
*  顺序表的基本操作声明
***********************************************************/

//创建并初始化为空表 
Status InitList(SqList &L);

//判断表L是否为空表 
bool ListEmpty(SqList L);

//求表L的长度 
int ListLength(SqList L);

//取表L中的第i个元素,并用e返回. 操作成功返回OK,失败时返回ERROR 
Status GetElem(SqList L, int i, ElemType &e);

//在表L中定位元素e首次出现的位置. 操作成功返回位序,失败时返回0 
//    compare(a,b) 为比较函数,匹配时返回true,否则返回false 
//                 这里默认使用equal进行比较 
int LocateElem(SqList L, ElemType e, 
      bool (*compare)(ElemType,ElemType));

//在表L中插入第i个元素e. 操作成功返回OK,失败时返回ERROR
Status ListInsert(SqList &L, int i, ElemType e);

//删除表L中第i个元素,结果用e返回. 操作成功返回OK,失败时返回ERROR 
Status ListDelete(SqList &L, int i, ElemType &e);

//遍历表L,对每个元素调用visit(x). 
Status ListTraverse(SqList L, Status (*visit)(ElemType));
 

/**********************************************************
*  顺序表的基本操作的实现
***********************************************************/

//创建并初始化为空表 
Status InitList(SqList &L)
{
    // TODO (#1#): 创建空表 
	L.length=0;
    return OK;
    //-------------------------------------
}



//判断表L是否为空表 
bool ListEmpty(SqList L)
{   if(L.length==0)
       return true;
    // TODO (#1#): 顺序表判空 
    else    
        return false;
    //-------------------------------------
}

//求表L的长度 
int ListLength(SqList L)
{
    // TODO (#1#): 求顺序表长度
     int e=L.length;
    return e;
    //-------------------------------------
}

//取表L中的第i个元素,并用e返回. 操作成功返回OK,失败时返回ERROR 
Status GetElem(SqList L, int i, ElemType &e)
{
    // TODO (#1#): 取元素
	e=L.elem[i-1];
    return OK; 
    //-------------------------------------
}

//在表L中定位元素e首次出现的位置. 操作成功返回位序,失败时返回0 
//    compare(a,b) 为比较函数,匹配时返回true,否则返回false 
int LocateElem(SqList L, ElemType e, bool (*compare)(ElemType,ElemType))
{
    // TODO (#1#): 在表中查询元素e的位置,用compare(a,b)匹配元素
    for (int j=0; j<L.length; j++)
        if ( compare(L.elem[j],e) )  return j+1;
    return 0;
    //-------------------------------------
}


//在表L中插入第i个元素e. 操作成功返回OK,失败时返回ERROR
Status ListInsert(SqList &L, int i, ElemType e)
{
    // TODO (#1#): 在顺序表中插入元素
	if(i<1||i>L.length+1)
      return ERROR;
	for(int j=L.length;j>=i;j--)
	
	L.elem[j]=L.elem[j-1];
	
	
	L.elem[i-1]=e;
	++L.length;
	return OK;
    //-------------------------------------
}

//删除表L中第i个元素,结果用e返回. 操作成功返回OK,失败时返回ERROR 
Status ListDelete(SqList &L, int i, ElemType &e)
{
    // TODO (#1#): 在顺序表中删除元素
	if(i<1||i>L.length)
       return ERROR;
    
	   e=L.elem[i-1];
     for(int j=i;j<=L.length;j++)
	 	 
	 
	  L.elem[j-1]=L.elem[j];
	  --L.length;
	 
	 return OK;
    //-------------------------------------
}

//遍历表L,对每个元素调用visit(x). 
Status ListTraverse(SqList L, Status (*visit)(ElemType))
{
    // TODO (#1#): 遍历顺序表 
    for (int j=0; j<L.length; j++)
        if ( ! visit(L.elem[j]) )  return ERROR;

二:链式存取结构

/*
  Name: linklist.h
  Copyright: 
  Author: 
  Date: 21-03-05 20:21
  Description: 
*/

#ifndef LINKLIST_H_INCLUDED
#define LINKLIST_H_INCLUDED

#include "ds.h" //for Status,OK ...

#ifndef ElemType
#define ElemType int /* 数据元素类型默认为 int */
#define ELEMTYPE_TAG
#endif

/**********************************************************
*  单链表的存储结构定义 
***********************************************************/
typedef struct LNode {
    ElemType data;
    struct LNode *next;
} LNode, *LinkList;


/**********************************************************
*  单链表的基本操作声明
***********************************************************/

//创建并初始化为空表 
Status InitList(LinkList &L);

//销毁整个表(从此之后不再可用) 
Status DestroyList(LinkList &L);

//将表L置空 
Status ClearList(LinkList &L);

//判断表L是否为空表 
bool ListEmpty(LinkList L);

//求表L的长度 
int ListLength(LinkList L);

//取表L中的第i个元素,并用e返回. 操作成功返回OK,失败时返回ERROR 
Status GetElem(LinkList L, int i, ElemType &e);

//在表L中定位元素e首次出现的位置. 操作成功返回位序,失败时返回0 
//    compare(a,b) 为比较函数,匹配时返回true,否则返回false 
//                 这里默认使用equal进行比较 
int LocateElem(LinkList L, ElemType e, 
      bool (*compare)(ElemType,ElemType));

//在表L中插入第i个元素e. 操作成功返回OK,失败时返回ERROR
Status ListInsert(LinkList &L, int i, ElemType e);

//删除表L中第i个元素,结果用e返回. 操作成功返回OK,失败时返回ERROR 
Status ListDelete(LinkList &L, int i, ElemType &e);

//遍历表L,对每个元素调用visit(x). 
Status ListTraverse(LinkList L, Status (*visit)(ElemType));
 

/**********************************************************
*  单链表的基本操作的实现
***********************************************************/

//创建并初始化为空表 
Status InitList(LinkList &L)
{
    // TODO (#1#): 创建空表
L=(LinkList) malloc (sizeof(LNode));
	 L->next=NULL;
 return OK;
    //-------------------------------------
}

//销毁整个表(从此之后不再可用) 
Status DestroyList(LinkList &L)
{
    // TODO (#1#): 销毁表
	LinkList M;
	if(L->next==NULL)
       return ERROR;
	while(M!=NULL)
	{
     M=L->next;
     free(L);
	 L=M;
	}
   return OK;
    //-------------------------------------
}

//将表L置空 
Status ClearList(LinkList &L)
{
    // TODO (#1#): 清空表
	if(L->next==NULL)
		return ERROR;
   while(L->next!=NULL)
	{LinkList M=L->next;
	  L->next=M->next;
	  free(M);
	}
    
		return OK;
    //-------------------------------------
}

//判断表L是否为空表 
bool ListEmpty(LinkList L)
{
    // TODO (#1#): 链表判空 
	if(L->next==NULL)    
       
		return true;
	else
         return false;
    //-------------------------------------
}

//求表L的长度 
int ListLength(LinkList L)
{
    // TODO (#1#): 链表求长度
   LinkList m;
 int i=0;
 m=L->next;
 while(m)
 {
  i++;
  m=m->next;
 }
 
 return i;

    //-------------------------------------
}

//取表L中的第i个元素,并用e返回. 操作成功返回OK,失败时返回ERROR 
Status GetElem(LinkList L, int i, ElemType &e)
{
    // TODO (#1#): 实现取元素GetElem(L,i,&e)
	LinkList M=L;int j=0;  // 初始化，P指向第一个结点，J为计数器
	while(M&&j<i)     //顺指针向后查找，知道P指向第i个元素或P为空
	{ M=M->next;
	  ++j;
	}
	if(M==NULL||j>i) 
		return ERROR;   //第i个元素不存在
	e=M->data;      //取第i个元素
    return OK; 
   
    //-------------------------------------
}

//在表L中定位元素e首次出现的位置. 操作成功返回位序,失败时返回0 
//    compare(a,b) 为比较函数,匹配时返回true,否则返回false 
int LocateElem(LinkList L, ElemType e, bool (*compare)(ElemType,ElemType))
{
    // TODO (#1#): 在表中定位元素e,用compare(a,b)匹配元素
    LinkList p;
    int j;
    p = L->next; j = 1;
   while(p!=NULL) {
       if( compare(p->data,e) )
		  return j;
        p=p->next;
	    j++;
    }
    return 0;
    //-------------------------------------
}


//在表L中插入第i个元素e. 操作成功返回OK,失败时返回ERROR
Status ListInsert(LinkList &L, int i, ElemType e)
{
    // TODO (#1#): 在链表中插入元素
	LinkList M=L;int j=0;
	while(M&&j<i-1)
	{
	M=M->next;
	++j;
	}
	if(M==NULL||j>i-1)
		return ERROR;
	LinkList q=(LinkList)malloc(sizeof(LNode));
	q->data=e;
	q->next=M->next;
	M->next =q;
    return OK;
   
    //-------------------------------------
}

//删除表L中第i个元素,结果用e返回. 操作成功返回OK,失败时返回ERROR 
Status ListDelete(LinkList &L, int i, ElemType &e)
{
    // TODO (#1#): 在链表中删除元素
	LinkList M=L;int j=0;
	while(M->next&&j<i-1)
	{
	M=M->next;
	++j;
	}
	if(!(M->next)||j>i-1)
		return ERROR;
      LinkList q=M->next;
	  M->next=q->next;
	  e=q->data;
	  
	  free(q);
	  return OK;
    
    //-------------------------------------
}

//遍历表L,对每个元素调用visit(x). 
Status ListTraverse(LinkList L, Status (*visit)(ElemType))
{
    LinkList p = L->next;
    while ( p ) {
        if ( visit(p->data)==ERROR )  return ERROR;
        p = p->next;
    }
    return OK;
}


#ifdef ELEMTYPE_TAG
#undef ElemType
#undef ELEMTYPE_TAG
#endif

#endif  // LINKLIST_H_INCLUDED

return OK; //-------------------------------------}#ifdef ELEMTYPE_TAG#undef ElemType#undef ELEMTYPE_TAG#endif#endif // SQLIST_H_INCLUDED