严蔚敏版数据结构------顺序表（ADT）的实现

2019年7月25日更新：

1.线性表的定义
若将线性表记为（a1,…,ai-1,ai,ai+1,…,an），则表中ai-1领先于ai，ai领先于ai+1，称ai-1是ai的直接前驱元素，ai+1是ai的直接后继元素。
线性表元素的个数n(n>=0)定义为线性表的长度，当n=0时，称为空表。

2.线性表的顺序存储结构
线性表的顺序存储结构，指的是一段地址连续的存储单元依次存储线性表的数据元素。
线性表的顺序存储结构如图所示：

2.1地址计算方法
用数组存储顺序表意味着要分配固定长度的数组空间，分配的数组空间大于等于当前线性表的长度，数据元素的序号和存放它的数组下标之间存在对应关系：

存储器的每个存储单元都有自己的编号，这个编号称为地址。
每个数据元素都需要占用一定的存储单元空间的，假设占用的是c个存储单元，对于第i个数据元素ai存储位置为（LOC表示获得存储位置的函数）：
LOC(ai) = LOC(a1) + (i-1)*c

摘自：https://www.01hai.com/note/av125008

---

快哭了。。开学快一个月，终于自己写成功线性表的源代码了！！！！好开心！！！！！！！！！！

期间查看了无数其他人的博客，又把谭浩强老师的C++翻了好几遍！！

该代码在codeblocks17.12上面测试。

**

忠告：学每一章的时候，不用把所有的ADT都实现，累死你不说，最主要的是肯定跟不上进度，所以，先学ADT中的增删改查，以后回过头再看其他的，不仅容易理解，还效率高。

**

其实应该感谢的是以为大神！@Cynical丶Gary
https://blog.csdn.net/m0_37243410/article/details/75107134

顺序表的理解参考以下：
https://blog.csdn.net/Song_JiangTao/article/details/79717012
（对于整个数据结构这本书的总结）
https://www.cnblogs.com/whatiwhere/p/8602319.html
（这个理解起来超级简单，超级棒！）

此代码缺点：
1.时间复杂度没算
2.两个线性表的合并没弄
3.好多关于指针的方面还是没懂！！！

PS:Visit()函数其实就是随便的什么访问动作都可以,比如printf()函数,但编者怕读者误以为遍历时只能使用printf或者其它的某一种函数,而不是什么都可以才写了一个从字面上理解就是访问的函数来表示,并不是什么特定的代码段的,

/*****************************************************
	** 文件名: Sequence List.cpp
	** Copyright (c) 2019 Asuka Shin
	** 创建人: 周志豪
	** 日 期:  2019.03.05
	** 修改人: 周志豪
	** 日 期:  2019.03.29
	** 描 述:  顺序表的实现
	** 版 本:  1.0
*****************************************************/

#include 
#include 
#include 
#include 

const int  LIST_INIT_SIZE = 100;
const int  LISTINCENTMENT = 10;
const int  OVERFLOW = -2;
const int  OK = 1;
const int  ERROR = 0;
const int  TRUE = 1;
const int  FALSE = 0;

/*在C中，int型和bool型一样，0为假，1为真*/

using namespace std;
typedef int Status;
typedef int ElemType;
typedef struct
{
    ElemType *elem; //存储空间的基地址，类似于数组的首地址，即elem所指向的变量
    int length;
    int listsize;

}SqList;
/*创建一个名为SqList的结构变量*/


/*操作结果：构造一个空的线性表L*/
Status InitList_Sq(SqList &L);


/*初始条件：线性表L已存在*/
/*操作结果：销毁线性表L*/
Status DestoryList_Sq(SqList &L);


/*初始条件：线性表L已存在*/
/*操作结果：将线性表L重置为空表*/
Status ClearList_Sq(SqList &L);


/*初始条件：线性表L已存在*/
/*操作结果：若线性表L为空表，则返回TRUE，否则返回FALSE*/
Status ListEmpty_Sq(SqList L);


/*初始条件：线性表L已存在*/
/*操作结果：返回线性表L中数据元素的个数*/
Status ListLength_Sq(SqList L);


/*初始条件：线性表L已存在，且1 <= i <=LIST_INIT_SIZE*/
/*操作结果：用e返回L中第i个数据元素的值*/
Status GetElem_Sq(SqList L,int i,ElemType &e);


/*辅助函数compare*/
Status compare(ElemType e1, ElemType e2);


/*初始条件：线性表L已存在，compare()是数据元素判定函数*/
/*操作结果：返回L中第一个与e满足关系compare的数据元素的位序。若这样的数据元素不存在，则返回值为0*/
int LocateElem_Sq(SqList L, ElemType e, Status(*compare)(ElemType,ElemType));


/*初始条件：线性表L已存在，且1 <= i <= ListLength(L)+1*/
/*操作结果：在线性表L中第i个元素之前插入新的元素e，且L的长度加1*/
Status ListInsert_Sq(SqList &L, int i, ElemType e);


/*初始条件：线性表L已存在且为非空，1 <= i <= ListLength(L)*/
/*操作结果：删除线性表L的第i个元素,用e返回其值，L的表长减1*/
Status ListDelete_Sq(SqList &L,int i,ElemType &e);


/*初始条件：线性表L已存在*/
/*操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义*/
Status PriorElem_Sq(SqList L, int cur_e, int &pre_e);


/*初始条件：线性表L已存在*/
/*操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回他的后续，否则操作失败，next_e无意义*/
Status NextElem_Sq(SqList L, int cur_e, int &next_e);


/*初始条件：线性表L已存在*/
/*操作结果：依次对L的每个数据元素调用函数visit(),一旦visit()失败，则操作失败*/
Status Travelselist_Sq(SqList L);


/*从小到大对顺序表进行排序*/
Status SortList_Sq(SqList &L);





/*操作结果：构造一个空的线性表L*/
Status InitList_Sq(SqList &L)
{
    L.elem = (ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    if(!L.elem)
        exit(OVERFLOW);
    L.length = 0;
    L.listsize = LIST_INIT_SIZE;
    return OK;
}

/*初始条件：线性表L已存在*/
/*操作结果：销毁线性表L*/
Status DestoryList_Sq(SqList &L)
{
   if(L.elem)
    free(L.elem);//如果存在数组，那么就释放这数组所占的空间

   /*如果不存在那么，它的基址也应该为空，表长为0，表占的空间也为0*/
   L.elem = NULL;
   L.length = 0;
   L.listsize = 0;
   return OK;
}


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

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

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


/*初始条件：线性表L已存在，且1 <= i <=LIST_INIT_SIZE*/
/*操作结果：用e返回L中第i个数据元素的值*/
Status GetElem_Sq(SqList L,int i,ElemType &e)
{
    if(i < 1 || i > LIST_INIT_SIZE)
        return ERROR;
    else
        e = L.elem[i-1];
        return e;
}

/*辅助函数compare*/
Status compare(ElemType e1, ElemType e2)
{
    if(e1 = e2)
        return e1;
    else
        return ERROR;
}

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


/*初始条件：线性表L已存在，且1 <= i <= ListLength(L)+1*/
/*操作结果：在线性表L中第i个元素之前插入新的元素e，且L的长度加1*/
Status ListInsert_Sq(SqList &L, int i, ElemType e)
{
   ElemType *p, *q, *newbase;
   if(i < 1 || i > L.length + 1)
    return ERROR;
   if(L.length >= L.listsize)
   {
       newbase = (ElemType*)realloc(L.elem,(L.listsize+LISTINCENTMENT)*sizeof(ElemType));
       if(!newbase)
        return(OVERFLOW);
       L.elem = newbase;
       L.listsize += LISTINCENTMENT;
   }
    q = &(L.elem[i-1]);
    for(p = &(L.elem[L.length - 1]);p >= q; --p)
        *(p+1) = *p;
    *q = e;
    ++ L.length;
    return OK;
}

/*初始条件：线性表L已存在且为非空，1 <= i <= ListLength(L)*/
/*操作结果：删除线性表L的第i个元素,用e返回其值，L的表长减1*/
Status ListDelete_Sq(SqList &L,int i,ElemType &e)
{
    ElemType *q, *p;
    if(i < 1 || i > L.length)
    return ERROR;
    p = &(L.elem[i-1]);
    e = *p;
    q = L.elem + L.length - 1;
    for(++p; p<=q; ++p)
        *(p-1)=*p;
    --L.length;
    return OK;
}

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



/*初始条件：线性表L已存在*/
/*操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回他的后续，否则操作失败，next_e无意义*/
Status NextElem_Sq(SqList L, int cur_e, int &next_e)
{
    for(int i = 0;i < L.length-1; i++)
    {
        if(cur_e == L.elem[i])
        {
            next_e = L.elem[i+1];
            return next_e;
        }

    }
}

/*初始条件：线性表L已存在*/
/*操作结果：依次对L的每个数据元素调用函数visit(),一旦visit()失败，则操作失败*/
Status Travelselist_Sq(SqList L)
{
    for(int i = 0; i < 1; i++)
        for(int j = 0; j < L.length; j++)
        {
            cout << " " << L.elem[j] <<" ";
        }

        return OK ;

}
/*从小到大对顺序表进行排序*/
Status SortList_Sq(SqList &L)
{
    for(int i = 0; i < L.length -1; i++)
      for(int j = 0; j <= L.length-i-1; j++)
      {
          if(L.elem[j] > L.elem[j+1])
          {
              int temp = L.elem[j];
              L.elem[j] = L.elem[j+1];
              L.elem[j+1] = temp;
          }
          return OK;
      }


}

int main()
{
    SqList L;

    ElemType e1, e2;

    Status k;

    int i,a,c,d,e,n,j;
    cout << "******************************\n"<> n;                        //向线性表中插入数据
    /*开始输入要操作的元素*/

    cout << " 输入你想设置空表中" <> a;
        ListInsert_Sq(L,i,a);
    }
    /*输入完毕*/

    /*开始下一步*/
    cout << " 请进行下一步的操作: ";

    while(cin >> c && c != 0)
    {

       if(c == 1)
        {
           SortList_Sq(L);
           cout << " 线性表成功由小到大进行排序 " << endl;
        }
       /*如果选择“1.排序”，则执行自己定义的SortList_Sq()函数*/

       else if(c == 2)
       {
           if(ListEmpty_Sq(L))
            {
               cout << " 线性表是空表 " << endl;
            }
           else
              {
                cout << " 线性表不是空表 " << endl;
              }
       }
        /*如果选择”2.判断顺序表是否为空”，则执行自己定义的ListEmpty_Sq()函数*/

       else if (c == 3)
       {

           cout << " 线性表的元素个数为:  "
                <> i;
           if(i < 1 || i > ListLength_Sq(L))
            {
               cout << " 输入数值错误！" << endl;
               break;
            }
           else
            {
               cout << " 表中第" << i <<"个元素对应的数值为： " <<  GetElem_Sq(L,i,e) << endl;
            }

       }
       /*如果选择”4.寻找表中第i个元素 ”，则执行自己定义的GetElem_Sq()函数*/

       else if(c == 5)
       {
           cout << " 请输入要查找表中第i个值前驱和后继： ";
           cin >> i;
            if(i <= 1 || i >= ListLength_Sq(L))
             {
                cout << "输入数值错误" << endl;
                break;
             }
            else
             {
                cout << " 表中第" << i <<"个元素对应的前驱数值为： " << PriorElem_Sq(L,i,e) << endl;
                cout << " 表中第" << i <<"个元素对应的后继数值为： " << NextElem_Sq(L,i,e) << endl;

             }
       }

       else if (c == 6)
       {
           cout << " 请输入你所想插入的位置以及值： ";
           cin >> e >> d;

           ListInsert_Sq(L,e,d);

           if(ListInsert_Sq)
            cout << " 插入成功! " << endl;
           else
            cout << " 插入失败！ " << endl;
       }

       /*如果选择”6.插入 ”，则执行自己定义的ListInsert_Sq()函数*/

       else if(c == 7)
       {
           cout << " 请输入删除第几个元素：" ;
           cin >> c;
           if(c < 1 || c > L.length)
            cout << "输入错误！，元素不存在" << endl;
           else
            k = ListDelete_Sq(L,c,e2);
           cout << " 删除第" << c <<"个元素成功，其值为: " << e2 << endl;
       }
       /*如果选择”7.删除  ”，则执行自己定义的ListDelete_Sq()函数*/

     else if (c == 8)
     {
         Travelselist_Sq(L);
         cout << endl;
     }
     /*如果选择”8.遍历输出  ”，则执行自己定义的Travelselist_Sq()函数*/

      else if(c == 9)
      {
          ClearList_Sq(L);
          if(ClearList_Sq(L) == 0)
            cout << " 清空成功 " << endl;
          else
            cout <<" 清空失败 " << endl;
      }
      /*如果选择”9.清空   ”，则执行自己定义的ClearList_Sq()函数*/

      else if (c == 10)
      {
          DestoryList_Sq(L);
          if(DestoryList_Sq(L) == OK)
            cout << " 销毁成功！" << endl;
          else
            cout << " 销毁失败！ " << endl;
      }

      cout << " 请进行下一步的操作: " << " ";

    }
    cout << " 成功退出 " << endl;
    return 0;
  }