线性表中常见的插入与删除操作

线性表中最重要的操作就是插入与删除操作了，但因为线性表中物理存储结构的多样性，导致我们经常精神错乱，今天我们就对其中的插入与删除操作进行总结一下。

1.顺序存储结构的插入与删除操作

众所周知，线性表的顺序存储结构类型分为两种，一种是动态的，一种是静态的，由于静态数组不能扩展的原因而不常用，这里就主要讲动态数组类型的线性表了：

//动态数组的顺序存储结构类型

define LISTSIZE 100；//数组的初始存储容量

define LIST_INCREASE 10//动态数组每次增加时，添加的存储容量

typedef struct list{

          ElemType *elem;//动态数组的首地址

          int length;//线性表的长度

          int listsize;//动态数组的初始存储容量

} sqList

//静态数组的顺序存储结构类型

define LISTSIZE 100;

typedef struct list{

           ElemType elem[LISTSIZE];

           int len;

}

 这里的ElemType是指对应的数据类型，下面我们就用int来代替。

插入：

//这是静态数组类型的线性表的插入操作

int  Sqlistinsert(sqlist *s,int pos,int num){

      //在线性表中第pos个位置之后插入一个值为num的数据项

      int i;

      if(pos<0&&pos>s->len)

            return 0;

      if(s->len==MAXLEN)

            return 0;

     //将pos后的每个元素向后移动一个位置，为即将插入的元素提供位置

     for(i=s->len-1;i>po

s;i--){

         s->data[i+1]=s->data[i];

         }

     s->data[pos]=num;

}

//这是动态的

//在线性表的第i个位置插入

InsertList(sqList &L,int i,int e){

 //插入位置是否错误

         if(i<0&&i>L.length+1){

              return 0;

          }

//插入前线性表的长度与动态数组的存储容量是否相等，若相等，则为动态数组添加存储容量

          if(L.length>=l.listsize){

             sqList *s；

             s=(int *)rellaoc(L.elem,(LISTSIZE+LIST_INCERSE)*sizeof(int));

             if(s=NULL) return 0;

            L.elem=s;

            L.listsize+=LIST_INCREASE;

           }

//插入操作。

       for(int j=L.length-1;j>=i;j--){

            L.elem[j+1]=L.elem[j];

        }

        L.elem[i-1]=e;

        L.length++;

//      int* q=&(L.elem[i-1]);

//     for(int p=&(L.elem[L.length-1]);p>=q;p--){

//           *(p+1)=*p;

//           }

//      *q=e;

//       L.length++;

}

以上静态的代码需要注意的是需要从最后一个元素开始向后移动，直到移动到第pos+1个位置，防止元素被覆盖。

其中动态数组类型中最后的注释部分是使用指针来移动的，需要注意的是，不要忘记了，最后给线性表的长度加一。

若是第pos个位置之前插入：

for(i=s->len-1;i>pos-1;i--){

      s->data[i+1]=s->data[i];

}

两者的区别仅在于第pos个位置之前的是第pos个位置也需要向后移动，而之后则不需要。

其次是线性表的删除：

//这是静态的

int Sqlistdel(sqlist *s,int pos){

     //删除线性表中第pos个元素

      if(pos<0&&pos>s->len)

              return 0;

      for(int i=pos-1;i<s->len-1;i++){

           s->data[i]=s->data[i+1];

      }

      s->len--;

}

以上代码需要注意的是从删除位置的下一个元素开始，向前移动一个位置，即从前向后。

//这是动态的

int DeleteList(sqList &L,int e)

//删除线性表中第i个元素

{

       if(i<0&&i>L.length)   

           return 0;

        int e=L.elem[i-1];

        for(int j=i-1;j<L.length-1;i++){

             L.elem[j]=L.elem[j+1];

        }

       L.length--;

}

我们能发现两者的删除操作异曲同工，非常相似，在删除操作中的for循环有这一种，但是，也可以写成for(int j=i;j<=L.lenth-1;j++){L.elem[j-1]=L.elem[j]},相比之下，两者区别不大，我们只要记住要开始是给下标为i-1赋值，结束是给下标为L.length-2赋值。

for循环，你要知道循环的对象是谁，从哪到哪，开始与结束的是否正确，这是我们需要注意的点。

2.链式存储结构的插入与删除操作

Typedef struct Node{

           ElemType elem;//该节点的数据域

           struct Node *next;//该节点直接后继的地址

}Lnode,*LinkList;

其中需要注意的是，Node的数据类型只是链表中的节点，链表的数据类型是LinkList，其是头指针，是链表的唯一标识，其指向头节点。

接下来的插入与删除操作均是在有头结点的情况下进行的。但需要提一嘴的是，若没有头结点，其线性表的插入与删除要为第一个节点进行分类讨论。

先来插入：

//在链表的第i个位置进行插入

int LinkLIstInsert(LinkList &L,int i,int e){

    Lnode *s=L.next；//链表的第一个节点

    int length=1;

    while(s!=NULL){

             s=s->next;

             length++;

     }

     if(i<0&&i>length)

       return 0;

     for(int j=1;j<i;j++){

          s=s->next;//链表中第i-1个节点

      }

     Lnode *p;

     p->elem=e;

     p->next=s->next;

     s->next=p;

}

作为链表的优点之一，其的插入十分简单，只需要找到第i-1个节点，并通过后继节点的地址进行操作就可以了，删除也是同理。

删除：

int DeleteLink(LinkList &L,int i,int &e){

        Lnode *s=L.next;//链表的第一个节点

        int length=1;

        while(s!=NULL){

                s=s->next;

                length++;

     }

        if(i<0&&i>length)

                return 0;

        for(int j=0;j<i;j++){

                s=s->next;//找到第i-1个节点

        }

        Lnode *p=s->next;

        e=p->elem;

        s->next=p->next;

        free(p);

}

综上所述，链表的插入与删除更加简单，时间复杂度更小，所以今后我们在选择顺序存储还是链式存储时，都要考虑插入与删除操作是否多，若多，尽量选择，链表，若少，则选择顺序表，毕竟其可以进行随机存取，这是链表无法做到的，毕竟它需要从前往后一个一个的寻找。

谢谢大家的认真观看，若有错误或有意思的方法，可以在评论区讨论。