线性表_顺序存储

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
#define  LIST_INIT_SIZE  100
#define  LISTRECREMENT 10
// 创建线性表的结构
// 头指针记录基地址
// 线性表的长度代表着最后一个成员的位置
struct  LinearTable{
    int*  head;
    int   length;
    int   listsize;
};


// 初始化线性表
// 长度为0，以后每增加一个元素，长度自增，“0”号地址不存放数据
int  InitList(LinearTable  &L){
     L.head=(int*)malloc ((LIST_INIT_SIZE)*sizeof(int));
     if(!L.head)
        return -1;
     L.length=0;
     L.listsize=LIST_INIT_SIZE;
         return  0;
}


// 摧毁线性表，线性表元素依然存在，但是内部结构已经被释放
// free掉头指针指向的后面的内存单元
int  DestroyList(LinearTable  &L){
     L.length=0;
     free(L.head);
     return 0;
}


// 清空线性表，线性表的结构依然存在，但是长度为0
void  ClearList(LinearTable  &L){
     if(L.length<=0)
        return;
    // 之前储存的元素依然储存在内存单元里，但是后面的操作会覆盖
     L.length=0;
}


// 判断线性表是否为空
bool  ListEmpty(LinearTable  &L){
      if(L.length==0)
        return true;
      return false;
}


// 求线性表的长度，元素的个数
int  ListLength(LinearTable  &L){
      if(L.length<0)
        return -1;
      return (L.length);
}


//  由位置信息定位元素，返回该元素
void  GetElem(LinearTable  &L,int location,int &e){
    // 判断是否为空 ，或者位置是否大于线性表的长度
    // 若没有元素打印显示error！
      if(ListEmpty(L) || location > L.length){
        printf("ERROR !\n");
        return ;
      }
      // 返回定位所求的元素
      e=*(L.head+location);
      return ;
}


//  相等比较函数
bool  Compare_Equ(int a,int b){
      return a==b;
}


//  大于比较函数
bool  Compare_Gt(int a,int b){
      return a>b;
}


//  小于比较函数
bool  Compare_Lt(int a,int b){
      return a<b;
}


//  根据比较函数定义定位功能
//  返回第一个满足该功能的元素的位置下标
int  LocateElem(LinearTable  &L,int e, bool (*fun)(int ,int )){  //在使用指向函数的指针的时候后面的参数也要标明


      for(int i=1;i<=L.length;i++){
            //  调用比较函数判断满足条件的元素
          if((*fun)(*(L.head+i),e))
            return i;
      }
      // 未找到满足条件的元素返回-1
      return -1;
}


// 由现在的元素定位其前面一个元素
// 没有该元素或者该元素没有前驱返回-1
int PriorElem(LinearTable  &L,int cur_e,int &prior_e){
    for(int i=2;i<=L.length;i++){
        if(cur_e==*(L.head+i))
        {
            prior_e=*(L.head+i-1);
            return 0;
        }
    }
    return -1;
}


// 由现在的元素定位其后面一个元素
// 没有该元素或者该元素没有后驱返回-1
int NextElem(LinearTable  &L,int cur_e,int &next_e){
      for(int i=1;i<L.length;i++){
        if(cur_e==*(L.head+i))
        {
            next_e=*(L.head+i+1);
            return 0;
        }
    }
    return -1;
}


// 增加一个元素 （首先判断线性表是否还有位置可以插入）
int  AddElem(LinearTable  &L,int e){
      if(L.length >= L.listsize){
            // 若线性表已满，需要增加分配内存空间
            // reallo(当前指针，扩展后内存空间大小)
            int* tmp=(int*)realloc(L.head,(L.listsize+LISTRECREMENT)*sizeof(int));
            if(!tmp)
                return -1;
            L.head=tmp;
      }
      // 线性表长度变化
      ++(L.length);
      *(L.head+L.length)=e;
      return 0;
}


// 插入元素，更新线性表
int InsertElem(LinearTable  &L,int location,int e){
     // 判断插入位置是否合法
     if(location < 1 || location > L.length)
        return -1;
     // 若线性表已满，需要增加分配内存空间
     if(L.length==L.listsize){
        int* tmp=(int *)realloc(L.head,(L.listsize+LISTRECREMENT)*sizeof(int));
        if(!tmp)
            return -1;
        L.head=tmp;
     }
     // 从定位下标开始，将该元素向后移动一位
     ++L.length;
     for(int i=location;i<=L.length;i++)
        *(L.head+i+1)=*(L.head+i);
     *(L.head+location)=e;
     return 0;
}


// 删除元素，更新线性表
int DeleteElem(LinearTable  &L,int location){
    // 判断位置是否合法
      if(location < 1 || location > L.length)
        return -1;
      for(int i=location;i<=L.length;i++)
        *(L.head+i)=*(L.head+i+1);
      --(L.length);
      return 0;
}


// 线性表排序
int SortList(LinearTable  &L){
    int tmp=0;
    if(ListEmpty(L))
        return 0;
    for(int i=1;i<L.length;i++){
        int k=i;
        for(int j=i+1;j<=L.length;j++){
             if(*(L.head+j)<*(L.head+k))
                k=j;
       }
       // 若当前位置不是当前的最小值，将当前的最小值放在当前位置
       if(k!=i){
            tmp=*(L.head+k);
            *(L.head+k)=*(L.head+i);
            *(L.head+i)=tmp;
        }
    }
    return 0;
}


// 合并两个顺序线性表
LinearTable MergeList(LinearTable  &La,LinearTable  &Lb){
     LinearTable Lc;
     InitList(Lc);
     int i=1;
     int j=1;
     while(i<=La.length && j<=Lb.length){
         // La中元素小，放入Lc中
         if(*(La.head+i)<*(Lb.head+j)){
            AddElem(Lc,*(La.head+i));
            ++i;
         }
        // La中元素小，放入Lc中
         else if(*(La.head+i)>*(Lb.head+j)){
            AddElem(Lc,*(Lb.head+j));
            ++j;
         }
         // 相等，任意线性表向后移动知道出现较小元素
         else
            ++i;
     }
     while(i<=La.length){
         AddElem(Lc,*(La.head+i));
         ++i;
     }
      while(j<=Lb.length){
         AddElem(Lc,*(Lb.head+j));
         ++j;
     }
     return Lc;
}


// 遍历线性表
int ListTraverse(LinearTable  &L){
     // 判断线性表是否为空
     if(ListEmpty(L))
        return -1;
     for(int i=1;i<L.length;i++)
        printf(" %d ->",*(L.head+i));
     printf(" %d\n",*(L.head+L.length));
        return 0;
}
int main(){
    int pri_e,nex_e;
    LinearTable La;
    InitList(La);
    AddElem(La,3);
    AddElem(La,1);
    ListTraverse(La);
    InsertElem(La,2,5);
    SortList(La);
    ListTraverse(La);
    if(PriorElem(La,5,pri_e) !=-1)
          printf(" 该元素的前驱是 %d\n",pri_e);
    else
          printf("  ERROR ! \n");
    if(NextElem(La,5,nex_e) != -1)
          printf(" 该元素的后驱是 %d\n",pri_e);
    else
          printf(" ERROR ! \n");
    LinearTable Lb;
    InitList(Lb);
    AddElem(Lb,2);
    AddElem(Lb,4);
    AddElem(Lb,5);
    AddElem(Lb,6);
    AddElem(Lb,8);
    int loca=LocateElem(Lb,4,Compare_Equ);
    if( loca!=-1)
        printf(" 相等元素为第 %d 个元素\n",loca);
    else
        printf(" ERROR ! \n");
    loca=LocateElem(Lb,4,Compare_Gt);
    if( loca!=-1)
        printf(" 首个大于当前元素的为第 %d 个元素\n",loca);
    else
        printf(" ERROR ! \n");
    ListTraverse(La);
    ListTraverse(Lb);
    LinearTable Lc=MergeList(La,Lb);
    ListTraverse(Lc);
    return 0;
}