数据结构_线性表

如果你是为了完成老师的作业，建议不要照抄照搬，自己敲。

线性表的顺序表示和实现 

#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <stack>
#include <set>//日常头文件
#define ll long long
#define list_size 100//线性表储存空间的初始分配量(最大存储量！)
#define list_increment 10//线性表存储空间的分配增量(本代码用的是数组，不能动态增加空间~)
#define Datatype int
#define Status int
#define OK 1
#define False 0
using namespace std;
/*
实现：
线性表的初始化，销毁，判断是否存在，长度，元素的位置，位置的元素,前驱元素，后驱元素，
插入元素，删除元素，线性表的遍历*/
typedef struct {
  Datatype data[list_size];//用数组来表示顺序表
  int length;//线性表的当前长度
} sq_list;
//线性表的初始化
Status init_list(sq_list &L) {
  for(int i=0; i<=list_size; i++) {
    L.data[i]=0;//初始化为空
  }
  L.length=0;//空表的长度为0；
  return OK;
}
//线性表的长度
Status length_list(sq_list L) {
  return L.length;
}
//线性表的销毁
Status destory_list(sq_list &L) {
  for(int i=0; i<=length_list(L); i++) {
    L.data[i]=0;
  }
  L.length=0;
  return OK;
}
//判断是否存在
Status empty_list(sq_list L) {
  if(L.length==0)
    return OK;//为空
  else return False;//不为空
}
//查找第i个位置上的数据
Status getelem_list(sq_list L,int i,Datatype *e) {
  if(i<1||i>length_list(L)||empty_list(L)) {
    return False;
  }
  *e=L.data[i-1];
  return OK;

}
//查找数据在的第一个位置
Status locate_list(sq_list L,Datatype e) {
  for(int i=0; i<length_list(L); i++) {
    if(L.data[i]==e)
      return i+1;//返回第几个位置。因为是第 所以加1
  }
  return False;
}
//前驱元素
Status priorelem_list(sq_list L,Datatype cur_e,Datatype *pre_e) {
  if(cur_e==L.data[0]) {
    return False;
  }
  int pos=locate_list(L,cur_e);
  if(pos==False) return False;
  else {
    *pre_e=L.data[pos-1-1];//这样好理解。
    return OK;
  }
}
//后驱元素
Status nextelem_list(sq_list L,Datatype cur_e,Datatype *nex_e) {
  if(cur_e==L.data[length_list(L)-1])
    return False;
  int pos=locate_list(L,cur_e);
  if(pos==False) return False;
  else {
    *nex_e=L.data[pos];
    return OK;
  }
}
//插入元素 在第i个位置插入e……(第第第)
Status insert_list(sq_list &L,int i,Datatype e) {
  if(i<1||i>list_size||length_list(L)>=list_size) {
    //大于等于 list_size就不能再插入了不然就超数组了
    return False;
  }
  for(int j=length_list(L)-1; j>=i-1; j--) { //i-1才是对应数组里的那个位置
    L.data[j+1]=L.data[j];
  }
  L.data[i-1]=e;
  L.length++;
  return OK;

}
//删除元素，删除第i个位置上的元素,返回返回这个元素的值
Status delete_list(sq_list &L,int i,Datatype *e) {
  if(i<1||i>length_list(L)||empty_list(L)) {
    return False;
  }
  *e=L.data[i-1];//要删除的元素
  for(int j=i; j<length_list(L); j++) {
    L.data[j-1]=L.data[j];
  }
  L.length--;
  return OK;

}
//遍历
void traverse_list(sq_list L) {
  if(!empty_list(L)) {
    for(int i=0; i<length_list(L); i++) {
      cout<<L.data[i]<<"  ";
    }
    cout<<endl;
  } else {
    cout<<"Not Found"<<endl;
  }
}
int main() {
  int n,a,pos;
  Datatype e,nex_e,pre_e,cur_e;
  sq_list L;
  cout<<"output the size of list: ";
  cin>>n;
  
  //list表的建立；利用了插入
  init_list(L);
  for(int i=1; i<=n; i++) {
    //第i个位置插入a
    a=rand()%100+1;
    //cout<<a<<"       ";
    insert_list(L,i,a);
  }
  cout<<"sq_list: ";
  traverse_list(L);
  cout<<endl;
  
  //在list 表中插入 新的元素
  cout<<"input the position and element of you wanting to insert: ";
  cin>>pos>>e;//在第pos位置插入e
  insert_list(L,pos,e);
  cout<<"output list after inserting: ";
  traverse_list(L);
  cout<<endl;
  
  //删除第pos个位置上的元素，并且返回这个元素
  cout<<"input the position you want to delete: ";
  cin>>pos;
  if(delete_list(L,pos,&e)) {
    cout<<"the deleted element: "<<e<<endl;
    cout<<"output list after deleting: ";
    traverse_list(L);
  } else cout<<"error"<<endl;
  cout<<endl;
  
  //查找当前元素的前驱元素
  cout<<"input the cur_e you want to search priorelem: ";
  cin>>cur_e;
  if(priorelem_list(L,cur_e,&pre_e)) {
    cout<<pre_e<<" is the previous letter of "<<cur_e<<endl;
  } else cout<<"error"<<endl;
  cout<<endl;
  
  //查找当前元素的后驱元素
  cout<<"input the cur_e you want to search nextelem: ";
  cin>>cur_e;
  if(nextelem_list(L,cur_e,&nex_e))
  {
    cout<<nex_e<<" is the next letter of "<<cur_e<<endl;
   }else cout<<"error"<<endl;
  cout<<endl;
  
  //查找第i个位置的元素并返回
  cout<<"input the element position you want to search: ";
  cin>>pos;
  if(getelem_list(L,pos,&e))
  {
    cout<<"The element of "<<pos<<"-th position is: "<<e<<endl; 
  }else cout<<"error"<<endl;
  cout<<endl;
  
  //查找元素在第几个位置
  cout<<"input the element you want to search: ";
  cin>>e;
  if(locate_list(L,e))
  {
    cout<<e<<" is the location is "<<locate_list(L,e)<<endl;
   } else cout<<"error"<<endl;
   cout<<endl;
   
  //所有情况已经实现，清空list
  cout<<"Destory_list is coming!!!(〃'▽'〃)" <<endl;
  if(destory_list(L))
  {
    cout<<"destory finished!"<<endl;
  }else cout<<endl<<"Goodbye~"<<endl;
  return 0; 
}

遇到的问题：L->length 与 L.length 混用了，如果写L->length就会出错

解决： -> 是指针操作符， .点是结构操作符。如果L 是一个结构实例的指针，要用 -> 访问结构里的变量，而不能用点。如果L 是一个结构的实例而非指针，只能用点而不能用 -> 。

L->length 相当于 (*L)->length

比如：

struct student{ int length; } *L; 这个是指针 用L->length
struct student{ int length; } L; 这个用L.length

关于带 & 与 不带 & 的区别

带&的是引用型参数，它是地址传递，其实参会随着形参的改变而改变；不带&的参数是一般参数，是值传递，其实参不会随着形参的改变而改变。所以，结构改变，并且需要传回这种改变的要用引用型参数，否则用一般参数。getelem_list(sq_list L,int i,Datatype *e)是找到第i个元素的值，线性表的结构并未发生任何改变，所以参数L前面不用加&。insert_list(sq_list &L,int i,Datatype e)是在线性表L的第i个元素处插入一个数值为e的元素，线性表L的结构发生了改变，长度增加了，所以在L前必须加上&。如果不加，显示L时，新增元素就显示不出来，显示L的长度，也仍然是增加以前的值，比实际长度少1.

 

集合的交并和差运算的实现(老师课堂作业)

我刚开始理解错意思了……其实就是求 交集、并集、差集。。。。 

代码修改后：

#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <stack>
#include <set>//日常头文件
#define ll long long
#define list_size 100//线性表储存空间的初始分配量(最大存储量！)
#define list_increment 10//线性表存储空间的分配增量(本代码用的是数组，不能动态增加空间~)
#define Datatype int
#define Status int
#define OK 1
#define False 0
using namespace std;
/*
实现：
线性表的初始化，销毁，判断是否存在，长度，元素的位置，位置的元素,前驱元素，后驱元素，
插入元素，删除元素，线性表的遍历*/
typedef struct {
  Datatype data[list_size];//用数组来表示顺序表
  int length;//线性表的当前长度
} sq_list;
//线性表的初始化
Status init_list(sq_list &L) {
  for(int i=0; i<=list_size; i++) {
    L.data[i]=0;//初始化为空
  }
  L.length=0;//空表的长度为0；
  return OK;
}
//线性表的长度
Status length_list(sq_list L) {
  return L.length;
}
//线性表的销毁
Status destory_list(sq_list &L) {
  for(int i=0; i<=length_list(L); i++) {
    L.data[i]=0;
  }
  L.length=0;
  return OK;
}
//判断是否存在
Status empty_list(sq_list L) {
  if(L.length==0)
    return OK;//为空
  else return False;//不为空
}
//查找第i个位置上的数据
Status getelem_list(sq_list L,int i,Datatype *e) {
  if(i<1||i>length_list(L)||empty_list(L)) {
    return False;
  }
  *e=L.data[i-1];
  return OK;

}
//查找数据在的第一个位置
Status locate_list(sq_list L,Datatype e) {
  for(int i=0; i<length_list(L); i++) {
    if(L.data[i]==e)
      return i+1;//返回第几个位置。因为是第 所以加1
  }
  return False;
}
//前驱元素
Status priorelem_list(sq_list L,Datatype cur_e,Datatype *pre_e) {
  if(cur_e==L.data[0]) {
    return False;
  }
  int pos=locate_list(L,cur_e);
  if(pos==False) return False;
  else {
    *pre_e=L.data[pos-1-1];//这样好理解。
    return OK;
  }
}
//后驱元素
Status nextelem_list(sq_list L,Datatype cur_e,Datatype *nex_e) {
  if(cur_e==L.data[length_list(L)-1])
    return False;
  int pos=locate_list(L,cur_e);
  if(pos==False) return False;
  else {
    *nex_e=L.data[pos];
    return OK;
  }
}
//插入元素 在第i个位置插入e……(第第第)
Status insert_list(sq_list &L,int i,Datatype e) {
  if(i<1||i>list_size||length_list(L)>=list_size) {
    //大于等于 list_size就不能再插入了不然就超数组了
    return False;
  }
  for(int j=length_list(L)-1; j>=i-1; j--) { //i-1才是对应数组里的那个位置
    L.data[j+1]=L.data[j];
  }
  L.data[i-1]=e;
  L.length++;
  return OK;

}
//删除元素，删除第i个位置上的元素,返回返回这个元素的值
Status delete_list(sq_list &L,int i,Datatype *e) {
  if(i<1||i>length_list(L)||empty_list(L)) {
    return False;
  }
  *e=L.data[i-1];//要删除的元素
  for(int j=i; j<length_list(L); j++) {
    L.data[j-1]=L.data[j];
  }
  L.length--;
  return OK;

}
//遍历
void traverse_list(sq_list L) {
  if(!empty_list(L)) {
    for(int i=0; i<length_list(L); i++) {
      cout<<L.data[i]<<"  ";
    }
    cout<<endl;
  } else {
    cout<<"Not Found"<<endl;
  }
}
//集合的 交、并、差 
//定义四个集合  
/*l1,l2是原始集合，l3是交集，l4是并集，l1中删除l3的元素后就变成了差集*/
/*
交集：思路：算l2中的元素在l1中找，有相同的插入到l3中
并集：先在l4中插入l1的所有数据，然后在处理l2 遍历 不一样的插入 一样的略过
差集：在l1中删除l3中的元素,l1就变成差集集合了~~。 
*/
int main() {
  sq_list l1,l2,l3,l4;
  int n=10,e,pos;
  /*为了方便，把元素个数固定了~~~hhh*/
  /*初始化*/
  init_list(l1);
  init_list(l2);
  init_list(l3);//交 
  init_list(l4);//并 
  for(int i=1;i<=n;i++)
  {
    insert_list(l1,i,i);//在第i个位置插入i 
  }
  for(int i=1;i<=n;i++)
  {
    insert_list(l2,i,i*i);//在第i个位置插入i*i 
  }
  cout<<"L1: ";traverse_list(l1);
  cout<<"l2: ";traverse_list(l2); 
  cout<<endl;
  
  /*交集*/
  for(int i=0;i<length_list(l2);i++)
  {
    if(locate_list(l1,l2.data[i]))//在l1中找是否有l2中的元素 有相同的就插入l3 中 
    {
      int len3=length_list(l3)+1;
      insert_list(l3,len3,l2.data[i]); 
    }else continue;
  }
  cout<<"Intersection: ";
  traverse_list(l3);
  
  /*并集*/
  for(int i=0;i<length_list(l1);i++)
  {
    int len4=length_list(l4)+1;
    insert_list(l4,len4,l1.data[i]);
  } 
  //traverse_list(l4);
  for(int i=0;i<length_list(l2);i++)
  {//在l4中找有没有跟l2一样的元素，有点话略过 
    if(!locate_list(l4,l2.data[i]))
    {
      int len4=length_list(l4)+1;
      insert_list(l4,len4,l2.data[i]);
    }else continue; 
  } 
  cout<<"Union: ";
  traverse_list(l4);
  
  /*差集*/
  for(int i=0;i<length_list(l3);i++)
  {/*在l1中删除与l3一样的元素*/
   //先找位置
    pos=locate_list(l1,l3.data[i]);
    delete_list(l1,pos,&e); 
  } 
  cout<<"Difference set: ";
  traverse_list(l1);
  return 0;  
}

数组版：

#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstdio>
#include <string>
#include <cstring>
#define Max_size 100
using namespace std;
/*
求A,B集合的交并差
*/
int half_search(int a[],int l,int r,int key) { //建立在排好序的基础上
  while(l<=r) {
    int mid=(l+r)>>1;
    if(a[mid]==key) return mid;
    else if(a[mid]>key) r=mid-1;
    else l=mid+1;
  }
  return -1;
}
int main() {
  int a[Max_size]= {0},b[Max_size]= {0},c[Max_size*2]= {0},index1=0,index2=0,a1,b1;
  cout<<"输入集合A,集合B的元素(分别以-1结束)："<<endl;
  //输入操作
  while(cin>>a1) {
    if(a1==-1) break;
    if(half_search(a,0,index1,a1)==-1) {
      a[index1++]=a1;
      sort(a,a+index1);
    }
  }
  while(cin>>b1) {
    if(b1==-1) break;
    if(half_search(b,0,index2,b1)==-1) {
      b[index2++]=b1;
      sort(b,b+index2);
    }
  }
  cout<<"集合A: ";
  for(int i=0; i<index1; i++) {
    cout<<a[i]<<" ";
  }
  cout<<endl;
  cout<<"集合B: ";
  for(int i=0; i<index2; i++) {
    cout<<b[i]<<" ";
  }
  cout<<endl;
  /*并集*/
  cout<<"A∪B: ";
  for(int i=0; i<index1; i++) {
    c[i]=a[i];
  }
  int index3=index1;
  for(int i=0; i<index2; i++) {
    if(half_search(c,0,index3,b[i])==-1) {
      c[index3++]=b[i];
      sort(c,c+index3);
    }
  }
  for(int i=0; i<index3; i++)
    cout<<c[i]<<" ";
  cout<<endl;

  /*交集*/
  cout<<"A∩B: ";
  memset(c,0,sizeof(c));
  index3=0;
  for(int i=0; i<index1; i++) {
    for(int j=0; j<index2; j++) {
      if(a[i]==b[j]&&half_search(c,0,index3,b[j])==-1) {
        c[index3++]=b[j];
        sort(c,c+index3);
      }
    }
  }
  for(int i=0; i<index3; i++) {
    cout<<c[i]<<" ";
  }
  cout<<endl;

  /*差集*/
  memset(c,0,sizeof(c));
  index3=0;
  int flag=0;
  cout<<"A-B: ";
  for(int i=0; i<index1; i++) { //a
    flag=0;
//    cout<<"a: "<<a[i]<<" flag； "<<flag<<endl;
    for(int j=0; j<index2; j++) { //b
      if(a[i]==b[j]) {
        flag=1;
        break;
      }
    }
//    cout<<"Flag : "<<flag<<endl;
    if(!flag) {
//      cout<<"asdsa: "<<a[i]<<endl;
      c[index3++]=a[i];
      sort(c,c+index3);
    }
  }
  for(int i=0; i<index3; i++)
    cout<<c[i]<<" ";
  cout<<endl;
  return 0;
}

​​线性表的链式表示和实现（mycdsn）​​

更新于：2018.09.26 待完善……

#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <stack>
#include <set>//日常头文件
#define ll long long
#define list_size 100//线性表储存空间的初始分配量(最大存储量！)
#define list_increment 10//线性表存储空间的分配增量(本代码用的是数组，不能动态增加空间~)
#define Datatype int
#define Status int
#define OK 1
#define False 0
using namespace std;
/*
实现：
线性表的初始化，销毁，判断是否存在，长度，元素的位置，位置的元素,前驱元素，后驱元素，
插入元素，删除元素，线性表的遍历*/
typedef struct Node
{
    Datatype data;
    struct Node *next;
}node,*sq_list;
//线性表的初始化
Status init_list(sq_list *L)
{
    *L=(sq_list)malloc(sizeof(Node));//创建一个头结点 
    if(!(*L))
    {
        return False;
    } 
    (*L)->next=NULL;//指针域为空 
    return OK; 
}
//线性表的长度 
Status length_list(sq_list L)
{
    int len=0;
    sq_list p=L->next;
    while(p!=NULL)
    {
        len++;
        p=p->next;
    } 
    return len;
}
//清空链表 
Status clear_list(sq_list *L)
{
    sq_list p,q;
    p=(*L)->next;
    while(p)
    {
        q=p->next;
        free(p);
        p=q;
    }
    (*L)->next=NULL;
    return OK;
}
//销毁 链表
Status destory_list(sq_list *L)
{
    sq_list q;
    while(*L)
    {
        q=(*L)->next;
        free(*L);
        *L=q;
    }
    return OK;
 } 
//建立线性表 尾插法
// n 个 元素  
void create_list_tail(sq_list *L,int n)
{//例子：插入的结点顺序为 1 2 3 4 5 输出也是 1 2 3 4 5 按顺序 
    sq_list p,r;
    //r是 尾 一直记录插入的最后一个元素 
    *L=(sq_list)malloc(sizeof(Node));//头结点 
    r=*L;
    for(int i=1;i<=n;i++)
    {
        p=(Node *)malloc(sizeof(Node));
        p->data = rand()%10+1;
        //cout<< p->data <<"   ";
        r->next=p;
        r=p;
    }
    r->next=NULL;
} 
//建立线性表 头插法(画图理解！！！！！)
//n个元素
void create_list_head(sq_list *L,int n)
{//头插法 例子：插入的顺序是 1，21,31,321，2,； 则输出的顺序是 2,321，3,21,1  相反 
    sq_list p;
    *L=(sq_list)malloc(sizeof(Node));//头结点 
    (*L)->next=NULL;
    for(int i=1;i<=n;i++)
    {
        p=(sq_list)malloc(sizeof(Node));
        p->data=rand()%10+1;
        //cout<<p->data<<"   ";
        p->next=(*L)->next;
        (*L)->next=p; 
    }
} 
//查找第i个位置的数据 
Status getelem_list(sq_list L,int i,Datatype *e)
{
    if(i<1||i>length_list(L))
    return False;
    sq_list q=L->next;
    int len=0;
    while(q)
    {
        len++;
        if(len==i)
        {
            *e=q->data;
            return OK;
        }
        q=q->next;
    }return False;
} 
//查询e的位置 
Status locate_list(sq_list L,Datatype e)
{
    int len=0;
    sq_list q;
    q=L->next;
    while(q)
    {
        len++;
        if(q->data==e)
            return len;
        q=q->next;
    }
    return False;
    
}
//在第pos个位置插入元素
Status insert_list(sq_list *L,int pos,Datatype e)
{
    if(pos<1||pos>length_list(*L)) return False;
    sq_list q,p;
    int len=0;
    q=*L;//先指向头节点 
    len=1;//len 要比 q 的位置大一  因为要找的是 pos位置的前驱结点 
    while(q&&len<pos) //寻找pos位置的节点 
    {
        q=q->next;
        len++;
    }
    if(!q||len>pos)//pos位置的元素不存在 
    return False; 
    p=(sq_list)malloc(sizeof(node));
    p->data=e;
    p->next=q->next;
    q->next=p;
    return OK; 
} 

//在第pos位置删除结点，并且，返回这个被删除结点的data
Status delete_list(sq_list *L,int pos,Datatype *e)
{
    int len=0;
    sq_list q,p;
    p=*L;
    len=1;
    while(p->next&&len<pos)//寻找 第pos个元素 
    {
        p=p->next;
        len++; 
    }
    if(!(p->next)||len>pos)
    return False;//pos 位置 元素不存在 
    q=p->next;//q是要删除 
    p->next=q->next;//p=p->next->next; 
    *e=q->data;
    free(q);
    return OK;
}
//前驱元素
//Status priorelem_list(sq_list L,Datatype cur_e,Datatype *pre_e) {
//  if(locate_list(L,cur_e)==1||!locate_list(L,cur_e))//如果cur_的位置为1而且没有当前的这个元素的话说明没有 前驱元素 
//  return False;
//  int len=0;
//  sq_list h,r;
//  r=L->next;
//  len++;
//  h->next=r;
//  while(r)
//  {
//      if(r->data == cur_e)
//      {
//          *pre_e=h->data;  
//      }
//      r=r->next;
//      h->next=r;
//      len++;   
//  }
//  return OK; 
//   
//}

//后驱元素
//
//输出
void traverse_list(sq_list L)
{
    sq_list p=L->next;
    while(p)
    {
        cout<< p->data <<"  ";
        p=p->next;
    } 
}
int main()
{
    sq_list L;
    int n,pos,e,cur_e,nex_e,pre_e;
    cin>>n;
    /*这是头插法 
    init_list(&L);
    cout<<"insert head"<<" : ";
    create_list_head(&L,n);
    cout<<endl;
    traverse_list(L);
    cout<<endl;
    */
    //保留尾插法，，好理解啊， 
    init_list(&L);
    cout<<"insert tail"<<" : ";
    create_list_tail(&L,n);
    cout<<endl;
    traverse_list(L);
    cout<<endl;
    //查询e的位置 
    cout<<"input the element you want to search: ";
    cin>>e;
    if(locate_list(L,e))
    {
        cout<<e<<" is the location is "<<locate_list(L,e)<<endl;
     } else cout<<"error"<<endl;
    cout<<endl;

    //查找第i个位置的元素并返回
    cout<<"input the element position you want to search: ";
    cin>>pos;
    if(getelem_list(L,pos,&e))
    {
        cout<<"The element of "<<pos<<"-th position is: "<<e<<endl; 
    }else cout<<"error"<<endl;
    cout<<endl; 
    
    //在第pos 位置插入元素 
    cout<<"input the position and element of you wanting to insert: ";
    cin>>pos>>e;//在第pos位置插入e
    if(insert_list(&L,pos,e))
    {
        cout<<"output list after inserting: ";
        traverse_list(L);
    }else cout<<"error"<<endl;
    cout<<endl;
    
    //删除第pos个位置上的元素，并且返回这个元素
    cout<<"input the position you want to delete: ";
    cin>>pos;
    if(delete_list(&L,pos,&e)) {
        cout<<"the deleted element: "<<e<<endl;
        cout<<"output list after deleting: ";
        traverse_list(L);
    } else cout<<"error"<<endl;
    cout<<endl;
    
    //查找当前元素的前驱元素 思路 查找当前元素的位置，然后找上个位置的元素 
    cout<<"input the cur_e you want to search priorelem: ";
    cin>>cur_e;
    if(locate_list(L,cur_e)) {
        int poss=locate_list(L,cur_e);//第一个位置的话就没有 前驱节点了，= = 
        if(poss==1)  cout<<"error"<<endl;
        else 
        {   
            getelem_list(L,poss-1,&pre_e); 
            cout<<pre_e<<" is the previous letter of "<<cur_e<<endl;
        }
    
    } else cout<<"error"<<endl;
    cout<<endl;
    
    //查找当前元素的后驱元素
    cout<<"input the cur_e you want to search nextelem: ";
    cin>>cur_e;
    if(locate_list(L,cur_e))
    {
        int poss=locate_list(L,cur_e);
        if(poss==length_list(L)) cout<<"error"<<endl;
        else
        {
            getelem_list(L,poss+1,&nex_e);
            cout<<nex_e<<" is the next letter of "<<cur_e<<endl;
        }
    
     }else cout<<"error"<<endl;
    cout<<endl;
    
    //销毁
    cout<<"Destory_list is coming!!!(〃'▽'〃)" <<endl;
    if(destory_list(&L))
    {
        cout<<"destory finished!"<<endl;
    }else cout<<endl<<"Goodbye~"<<endl; 
    return 0;
}

在顺序表中插入和删除一个元素，平均需要移动多少个元素

插入 n/2   ——>(n+n-1+.....+0)/(n+1) = n/2; 

删除 （n-1）/2  ——>(n-1+n-2+.....+0)/(n) = (n-1)/2;