线性表顺序实现

#ifndef SQLIST_H
#define SQLIST_H

 

#define INIT_SIZE 10
#define LISTINCREMENT 2

 

/* 函数结果状态代码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

 

typedef int ElemType;
typedef int Status;
typedef struct
{
 int *elem;
 int length;
 int list_size;
}SqList;

Status InitList(SqList *L);
Status DestroyList(SqList *L);
Status ClearList(SqList *L);
Status ListEmpty(SqList L);
Status ListLength(SqList L);
Status GetElem(SqList L, int i, ElemType *e);
int LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType));
Status PriorElem(SqList L, ElemType cur_e, ElemType *pri_e);
Status NextElem(SqList L, ElemType cur_e, ElemType *next_e);
Status ListInsert(SqList *L, int i, ElemType e);
Status ListDelete(SqList *L, int i, ElemType *e);
Status ListTraverse(SqList L, void(*visit)(ElemType *));

 

#endif

 

 

#include "head.h"
#include "sqlist.h"

/* 操作结果：构造一个空的顺序线性表 */
Status InitList(SqList *L)
{
 (*L).elem = (ElemType *)malloc(INIT_SIZE * sizeof(ElemType));
 (*L).length = 0;
 (*L).list_size = INIT_SIZE;
 return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：销毁顺序线性表L */
Status DestroyList(SqList *L)
{
 free((*L).elem);
    (*L).elem = NULL;
    (*L).length = 0;
    (*L).list_size = 0;  
    return OK;    
}

/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(SqList *L)
{
    (*L).length = 0;
    return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(SqList L)
{
    if (L.length == 0)
        return TRUE;
    else
        return FALSE;
}

/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
Status ListLength(SqList L)
{
    return L.length;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
 *  操作结果：用e返回L中第i个数据元素的值  */
Status GetElem(SqList L, int i, ElemType *e)
{
 if (i > L.length || i < 1)
  return ERROR;
  
    *e = *(L.elem + i - 1);
    return OK;
}

/* 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1,否则为0) */
/* 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。 */
/*           若这样的数据元素不存在，则返回值为0 */
int LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
 int i = 1;
 ElemType *p = L.elem;
 
 while (i < L.length && !compare(e, *p++))
  i++; 
 
 if (i <= L.length)
  return i;
 else  
  return 0; 
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱， */
/*           否则操作失败，pre_e无定义 */
Status PriorElem(SqList L, ElemType cur_e, ElemType *pri_e)
{
 ElemType *p = L.elem + 1;
 int i = 2;
 
 while (i < L.length && *p != cur_e)
 {
  i++;
  p++; 
 }
 
 if (i == L.length)
  return ERROR;
 else
 {
  *pri_e = *--p;
  return OK;
 } 
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继， */
/*           否则操作失败，next_e无定义 */
Status NextElem(SqList L, ElemType cur_e, ElemType *next_e)
{
 ElemType *p = L.elem;
 int i = 1;
 
 while (i < L.length && *p != cur_e)
 {
  i++;
  p++; 
 }
 
 if (i == L.length)
  return ERROR;
 else
 {
  *next_e = *++p;
  return OK;
 } 
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1 */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(SqList *L, int i, ElemType e)
{
 ElemType *p;
 ElemType *q;
 ElemType *newbase;

 if (i < 1 || i > (*L).length + 1)
  return ERROR;
 
 /* 当前存储空间已满,增加分配 */
 if((*L).length >= (*L).list_size)
    {
     newbase = (ElemType *)realloc((*L).elem, ((*L).list_size + LISTINCREMENT) * sizeof(ElemType));
     if(!newbase)
      exit(OVERFLOW); /* 存储分配失败 */
      
     (*L).elem = newbase; /* 新基址 */
     (*L).list_size += LISTINCREMENT; /* 增加存储容量 */
    }
    
 q = (*L).elem + i - 1;
 p = (*L).elem + (*L).length - 1;
 
 /* 元素依次向后移 */
 while (p > q)
 {
  *p = *(p - 1);
  p--;
 }
 
 *q = e;
  
 (*L).length++; 
 return OK;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(SqList *L, int i, ElemType *e)
{
 ElemType *p;
 ElemType *q;

 if (i < 1 || i > (*L).length + 1)
  return ERROR;
  
 p = (*L).elem + i - 1;
 q = (*L).elem + (*L).length - 1;
 
 *e = *p;
 
 /* 元素依次向前移 */
 while (p < q)
 {
  *p = *(p + 1);
  p++;
 }
 
 (*L).length--; 
 return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素调用函数visit()。一旦visit()失败，则操作失败 */
/*           visit()的形参加'&'，表明可通过调用visit()改变元素的值 */
Status ListTraverse(SqList L, void(*visit)(ElemType *))
{
 ElemType *p = L.elem;
 int i = 1;
 
 while (i <= L.length)
 {
  visit(p++);
  i++;
 }
 
 return OK;
}