线性表插入和删除——程序实例

顺序实现

.h文件 此文件为方法    
#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 /* 存储空间初始分配容量 */     
#define LISTINCREMENT 10 /* 存储空间分配的增量 */     
typedef struct {     
    ElemType *elem;    //存储空间基址     
    int length;        //当前长度      
    int listsize;      //当前已分配的存储空间(元素个数)      
} SqList;  

   
/**********************************************************     
*  顺序表的基本操作声明     
***********************************************************/
//创建并初始化为空表      
Status InitList(SqList &L);     
//销毁整个表(从此之后不再可用)      
Status DestroyList(SqList &L);     
//将表L置空      
Status ClearList(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); 
    
template <typename T> bool equal(T a, T b)     
{     
    return a==b;     
} 
    
//在表L中定位元素e首次出现的位置. 操作成功返回位序,失败时返回0      
//    compare(a,b) 为比较函数,匹配时返回true,否则返回false      
//                 这里默认使用equal进行比较   
   
int LocateElem(SqList L, ElemType e,      
      bool (*compare)(ElemType,ElemType)=equal<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.elem=(ElemType*)malloc(LIST_INIT_SIZE * sizeof(ElemType));     
    if(!L.elem)exit(OVERFLOW);     
    L.length=0;     
    L.listsize=LIST_INIT_SIZE;     
    return OK;     
    //-------------------------------------     
}     
//销毁整个表(从此之后不再可用)      
Status DestroyList(SqList &L)     
{     
    free(L.elem);     
    return OK;     
    //-------------------------------------     
}     
//将表L置空      
Status ClearList(SqList &L)     
{     
    // TODO (#1#): 清空表     
    L.length=0;     
    return OK;     
    //-------------------------------------     
}     
//判断表L是否为空表      
bool ListEmpty(SqList L)     
{     
    // TODO (#1#): 顺序表判空      
    if(L.length==0)     
        return TRUE;     
    else
    return FALSE;     
    //-------------------------------------     
}     
          
//求表L的长度      
int ListLength(SqList L)     
{     
    // TODO (#1#): 求顺序表长度     
    return  L.length;     
  
    //-------------------------------------     
}     
          
//取表L中的第i个元素,并用e返回. 操作成功返回OK,失败时返回ERROR      
Status GetElem(SqList L, int i, ElemType &e)     
{     
    // TODO (#1#): 取元素     
    if(ListEmpty(L))     
    {     
        printf("线性表L为空n");     
        return ERROR;     
    }      
    if(i<1||i>L.length)     
    {     
        printf("不存在%d位置的元素n",i);     
        return ERROR;     
    }     
    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;     
     if (L.length >= L.listsize) //判读存储空间是否已满     
    {     
        ElemType * newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));     
        if (!newbase)     
            exit(OVERFLOW);     
        L.elem = newbase;     
        LL.listsize = L.listsize + LISTINCREMENT;     
    }     
    ElemType *q = &(L.elem[i - 1]); //q指向第i个元素     
    ElemType *p;                     //p指向最后一个元素     
          
    for (p= &(L.elem[L.length - 1]); p >= q; p--) //从最后一个位置开始移动     
    {     
        *(p + 1) = *p;     
    }     
          
    *q = e;     
    L.length++;     
    return ERROR;     
    //-------------------------------------     
}     
          
//删除表L中第i个元素,结果用e返回. 操作成功返回OK,失败时返回ERROR      
Status ListDelete(SqList &L, int i, ElemType &e)     
{     
    // TODO (#1#): 在顺序表中删除元素     
if (L.length == 0) //判断表是否为空     
    {     
        printf("表为空n");     
        return ERROR;     
    }     
          
    if (i < 1 || i > L.length) //判断删除位置是否合法     
    {     
        printf("删除位置不合法n");     
        return ERROR;     
    }     
          
    ElemType *p = &(L.elem[i - 1]); //p指向待删除的元素     
    e = *p;     
    ElemType *q = &(L.elem[L.length - 1]);     
    //ElemType *q = L->elem + L->length - 1; //q指向最后一个元素     
    for (pp = p + 1; p <= q; p++) //p从待删除的后一个元素开始，直到最后一个元素，每个元素一次向前移动一个位置     
    {     
        *(p - 1) = *p;     
    }     
          
    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;     
    return OK;     
    //-------------------------------------     
}
.cpp文件 此文件为主函数    
#ifdef ELEMTYPE_TAG     
#undef ElemType     
#undef ELEMTYPE_TAG     
#endif     
#endif  // SQLIST_H_INCLUDED     
#include <stdio.h>     
#include <stdlib.h>     
#include "ds.h"     
#define ElemType int                 //数据元素的类型      
Status print(ElemType e);            // 打印数据元素的方法     
bool equal(ElemType a, ElemType b);  //比较两个元素相等的方法      
#include "sqlist.h"     
//打印顺序表内容      
void PrintLinkList(SqList L);     
int main()     
{     
    SqList L;     
              
    //1)初始化顺序表      
    InitList(L);     
              
    //2)插入一些元素: 12,23,34,45     
    ListInsert(L,1,12);     
    ListInsert(L,1,23);     
    ListInsert(L,1,34);     
    ListInsert(L,1,45);     
              
    //3)打印顺序表信息      
    printf("n开始时顺序表内容n");     
    PrintLinkList(L);     
    printf("ListLength(L) : %dn", ListLength(L));     
    printf("ListEmpty(L)  : %dn", ListEmpty(L));     
              
    //4)顺序表插入      
    printf("n请输入一个元素:");      
    ElemType x;     
    read(x);     
    printf("插入开头:");     
    ListInsert(L,1,x);     
    PrintLinkList(L);     
    printf("插入末尾:");      
    ListInsert(L,ListLength(L)+1,x);     
    PrintLinkList(L);     
              
    //5)顺序表删除     
    printf("n请选择删除第i(1..%d)个元素:", ListLength(L));     
    int i;     
    read(i);     
    ElemType e;      
    if ( ListDelete(L,i,e)==OK ) {     
        Status print(ElemType e);  //声明print(e)函数      
                  
        printf("删除"); print(e);     
        printf("成功n");     
    } else
        printf("删除失败.n");     
    printf("顺序表内容:");     
    PrintLinkList(L);     
              
    //6)元素定位     
    printf("n请输入一个元素以便定位:");     
    read(x);     
    i = LocateElem(L,x);     
    if ( i!=0 ) {     
        printf("该元素是表中的第%d个元素.n",i);     
    } else
        printf("该元素在表中不存在.n");      
              
    //7)清空顺序表     
    ClearList(L);     
    printf("n最后顺序表内容n");     
    PrintLinkList(L);     
    printf("ListLength(L) : %dn", ListLength(L));     
    printf("ListEmpty(L)  : %dn", ListEmpty(L));     
               
    //8)销毁顺序表      
    DestroyList(L);     
              
    system("PAUSE");     
    return 0;     
}     
          
// 打印数据元素的方法      
Status print(ElemType e)     
{     
    printf("%5d",e);     
    return OK;     
}     
          
//比较两个元素相等的方法     
bool equal(ElemType a, ElemType b)     
{     
    return a==b;     
}     
          
//打印顺序表内容      
void PrintLinkList(SqList L)     
{     
    ListTraverse(L,print); //遍历顺序表并print()每个元素      
    printf("n");     
}