数据结构与算法--删除的各种情况_数据结构删除算法思想-CSDN博客


bool Del_Min(Sqlist &L,int &e)
{
  //删除顺序表L中最小值元素的结点，并通过引用型参数e返回其值
  //若删除成功则返回true,否则返回false
  if(L.length=0)
     return false;//表空，返回false
  e=L.data[0];//给e一个默认初始值，初始化e
  int pos=0;//pos来记录最小元素的数组下标
  for(int i=1;i<L.length;i++)
  { //循环查找最小值元素
    if（L.data[i]<e)
     {
       e=L.data[i];//查找到更小的元素更新e的值
       pos=i;//用pos记录最小元素下标，发现更小的更新pos的值
     }
     L.data[pos]=L.data[L.length-1];//空出的位置由最后一个元素填补
     L.length--;//删除元素后长度减一
     return true;//删除成功
  }
}

2.单链表

思想：时间复杂度为O(n)，空间复杂度为O(1)

用p从头到尾扫描单链表，pre指向*p结点的前驱，用minp保存值最小的结点指针（初始为p),minpre指向*minp结点的前驱（初值为pre).一边扫描，一边比较，若p->data小于minp->data,则将p,pre,分别赋值给minp,minpre.扫描完毕，minp指向最小值结点，minpre指向最小值结点的前驱结点，再将minp所指结点删除即可。

代码：

LinkList Delete_Min(Linklist &L)
{
  //L是带头结点的单链表，本算法删除其最小值结点
  LNode *pre=L
  LNode*p=pre->next;//p为工作指针，pre指向其前驱
  while (p!=NULL)
  {
    if(p->data<minp->data)
    {
      //找到比之前找到的最小值结点更小的结点
      minp=p;
      minpre=pre;
    }
    //如果没找到，就指向下一个结点、
    pre=p;//继续扫描下一个结点
    p=p->next;
  }
  //此时已经找到了最小值结点minp，删除最小值结点
  minpre->next=minp->next;
  free(minp);//释放最小值结点的内存
  return L;
}

二.删除所有值为x 的元素

1.顺序表

方法一.

思想：

用k记录顺序表L中不等于x的元素个数（即需要保存的元素个数），遍扫描L边统计k,并将不等于x 的元素向前移动k个位置，最后修改L的长度

代码：

void del_x_1(Sqlist &L,int x)
{
  int k=0;//记录值不等于x的元素个数
  for（i=0;i<L.length;i++)
     if(L.data[i]!=x)
     {
       L.data[k]=L.data[i];
       k++;//不等于x的元素加一
     }
     L.length=k;//顺序表L的长度等于k
}

方法二

思想：

用 k记录顺序表L中等于x的元素个数，遍扫描L边统计k,并将不等于x 的元素向前移动k个位置，最后修改L的长度。

代码：

void del_x_2(Sqlist &L,int x)
{
  int k=0,i=0;//k记录值等于x 的元素个数
  while(i<L.length)
  {
   if(L.data[i]==x)
      k++;
   else
      L.data[i-k]=L.data[i];//当前元素前移k个位置
   i++；//i为遍历的顺序表的数组下标，遍历完之后转到下一个元素
   }
   L.length=L.length-k;//顺序表L的长度递减
}

2.单链表

（1）不带头结点

思想：

借助一个递归工作栈，深度为O(n),时间复杂度为O(n)。设f(L,x)的功能是删除以L为首结点指针的单链表中所有值等于x的结点，显然有f(L->next,x)的功能是删除以L->next为首结点指针的单链表中所有值等于x的结点。

终止条件：f(L,x)=不做任何事情；若L为空表

递归主体：f(L,x)=删除*L结点；f(L->next,x); 若L->data==x

f(L,x)=f(L->next,x);其他情况

代码：

void Del_X_3(Linklist &L,int x)
{
  //递归实现在单链表L中删除值为x的结点
  LNode *p;//p指向待删除的结点
  if（L==NULL）
       return ;//递归出口是L为空表
  if(L->data==x)//若L所指向的结点的值为x
  {
    p=L;//删除*L；并让L指向下一个结点
    L=L->next;
    free(p);
    Del_X_3(L,x);//递归调用
  }
  else//L所指向结点的值不为x
    Del_X_3(L->next,x);//递归调用Del_X_3函数
}

(2)带头结点

方法一

思想：

用p从头到尾扫描单链表，pre指向*P结点的前驱。若p所指结点的值为x,则删除，并让p移向下一个结点，否则pre,p指针同步后移一个结点。此方法使用范围广，只需修改if语句里面的内容，就可以实现删除结点的条件

代码：

void Del1(Linklist &L,int x)
{
  LNode*p=L->next;
  LNOde*pre=L;//置p和pre的初始值
  LNode*q;
  while(p!=NULL)
  {
    if(p->data==x)//如果删除的是介于s和t之间的结点，只需将if语句修改为if（p->data>s&&p->data<t）即可
    {
      //找到值为x的结点
      q=p;//q指向该结点
      p=p->next;//p指向下一个结点
      pre->next=p;//逻辑上删除*q结点
      free(q);//物理上释放q结点的空间
    }
    else
    {//否则pre和p同步右移
     pre=p; 
     p=p->next; 
    }
  }
}

方法二

思想：尾插法建立单链表

用p指针扫描L的多有结点，当其值不为x时，将其链接到L之后，否则将其释放。

代码：

void Del2(Linklist&L,int x)
{
  LNOde*p=L->next;
  LNOde*r=L;//r指向尾结点，其初值为头结点
  LNode*q;
  while(p!=NULL)
  {
    if(p->data!=x)
    {
      r->next=p;//*p不为x时将其链接到L的尾部
      r=p;//r指向尾结点，此时p结点就是尾结点
      p=p->next;//继续扫描
     }
   else
   {
     q=p;
     p=p->next;//继续扫描
     free(q);//释放空间
   }
  }
  r->next=NULL;//插入结束后置为指针为NULL
}

三.删除某范围内（s<x<t)的元素

1.顺序表

（1）有序顺序表

思想：

先寻找值大于等于s 的第一个元素（第一个删除的元素),然后寻找值大于t的第一个元素（最后一个删除的元素的下一个元素），要将这段元素删除，只需直接将后面的元素前移。

代码：

bool del_s_1(Sqlist &L,int s,int t)
{
  int i,j;
  if (s>=t||L.length==0)
     return false;//操作无意义返回false
  for(i=0;i<L.length&&L.data[i]<s;i++);
  /*寻找值大于等于s的第一个元素，所有满足小于s的情况都要i++直到推出循环，此时i的值就是我们寻找的值*/
   if(i>=L.length)
      return false;//所有元素值均小于s ,返回false
   for(j=i;j<L.length&&L.data[j]<=t;j++);
   //寻找值大于t的第一个元素同理于上面的for 循环
   for(;j<L.length;i++,j++)
      L.data[i]=L.data[j];//将大于t的元素顺序赋值给大于s的元素即可
   L.length=i;//i的值一直递增直到赋值完毕，表示新顺序表的表长
   return true;
}

（2）无序顺序表

思想：

从前往后扫描顺序表L，用K记录下元素值在s到t之间元素的个数（初始时k=0).对于当前扫描的元素，若其值不在s与t之间，则前移K个位置；否则执行k++.由于在s到t之间的元素仅仅移动一次，所以算法效率高

代码：

bool Del_s_t(SqList &L,int s,int t)
{
  int i,k=0;//k记录元素值在s到t之间元素的个数
  if(L.length==0||s>=t)
     return false;//线性表为空，或s,t不合法，返回false
  for(i=0;i<L.length;i++)
  {
    if(L.data[i]>=s&&L.data[i]<=t)
        k++;//如果在这个范围内，则宁k的值加一
    else
        L.data[i-k]=L.data[i];//当前元素前移K个位置
  }
  L.length-=k;//最终线性表的长度=原始长度减去k的值
  return true;
}

2.单链表

（1)有序单链表

（2）无序单链表

同上一个删除所有值为x的带头结点的单链表的代码

四.删除重复的元素

1.顺序表

（1）有序顺序表

思想：

有序顺序表中值相同的元素一定在连续的位置上，用类似于直接插入排序的思想，初始时将第一个元素视为非重复的有序表。之后依次判断后面的元素是否与前面非重复有序表的最后一个元素相同，若相同则继续向后判断，若不同则插入到前面的非重复有序表的最后，直至判断到表尾为止。

代码：

bool Delete_Same(SeqList &L)
{
  if(L.length==0)
     return false;//删除操作需要判断顺序表是否为空
  int i,j;//i存放第一个不相同的元素，j为工作指针
  for(i=0,j=1;j<L.length;j++)
      if(L.data[i]!=L.data[j])
      {
        //查找下一个与上个元素值不同的元素
        L.data[++i]=L.data[j];//查到后将元素前移
      }
   L.length=i+1;
   return true;
}

（2）无序顺序表

思想：散列表

代码：

2.单链表

思想：

既然有公共结点则说明，从某一个结点开始，它们的next域都指向同一个结点，由于每个单链表的结点只有一个next域，因此从第一个公共结点开始，之后的所有结点都是重合的。

代码：

LinkList Search_common(LinkList L1,LinkList L2)
{
  //本算法实现在线性的时间内找到两个单链表的第一个公共结点
  int len1=Length(L1),len2=Length(L2);//计算两个链表的表长
  Linklist longList,shortList;//分别指向表长较长和较短的链表
  if(len1<len2)//L1的表长较长
  {
    longList=L1->next;
    shortList=L2->next;
    dist=len1-len2;//表长之差
  }
  else
  {
    longList=L2->next;
    shortList=L1->next;
    dist=len2-len1;//表长之差
  }
  while(dist--)
     longList=longList->next;//表长的链表先遍历到第dist个结点，然后同步
  while(longlist!=NULL)
  {
    //同步寻找共同结点，最好的情况是第dist+1个结点就是公共结点，后面都相同
    if(longlist==shortlist)//找到第一个公共结点
       return longlist;
    else
    {
      longlist=longlist->next;//继续同步向后寻找
      shortlist=shortlist->next;
    } 
  }
  return NULL;//此时还没有返回longlist则表明没有找到公共结点，所以返回NULL
}