线性表相关代码

顺序表L递增有序，写一算法删除顺序表中值重复多余的元素
依次比较相邻的两个元素，若值相等则删除其中一个，否则继续向后查找，直至搜索完毕

void delete_repeat(SeqList *L)
{
    int i,j;
    i=1;
    while(i<=L->length-1)
        if(L->data[i]!=L->data[i+1])
            i++;//继续向下找
        else
        {
            for(j=i+2; j<=L->length; j++)
            {
                L->data[j-1]=L->data[j];//删除第i+1个元素
                L->length=L->length-1;
            }
        }
}

已知线性表长度为n，写一算法将线性表逆置
将表长的一半为循环控制次数，将表的第一个元素与最后一个元素交换，倒数第二个与第二个交换…，直到交换完为止

void converts(SeqList *A)
{
   DataType x;//temp
   int i,k;
   k=A->length/2;
   for(i=1;i<=k;i++)
   {
       x=A->data[i];
       A->data[i]=A->data[A->length-i+1];
       A->data[A->length-i+1]=x;
   }
}

在线性表中找出最大值和最小值的元素及其所在位置
扫描一遍同时找到最大值和最小值元素

void maxmin(SeqList *L,DataType &max,DataType &min,int &k,int &j)
{
   int i;
   max=L->data[1];min=L->data[1];
   k=j=1;
   for(i=2;i<=L->length;i++)
   {
       if(L->data[i]>max)
       {
           max=L->data[i];k=i;
       }
       else
       {
           if(L->data[i]<min)
           {
               min=L->data[i];j=i;
           }
       }
   }
}

写一算法，将一头结点指针为a的单链表A分解成两个单链表A和B，其中头结点分别为a和b，使得A链表中含有原链表A中的序号为奇数的元素，而B链表中含有原链表中序号为偶数的元素，并保持原来的相对顺序
先遍历A，当遇到序号为偶数的结点时，先将其删除，并在删除时把这些结点链接到B表中，一直到遍历结束。

void split(LNode *A，LNode *&B) 
{
   LNode *p,*q,*r;
   B = (LNode *)malloc(sizeof(LNode));
   B->next =NULL;
   p = A;//p指向A中当前判断结点的前驱结点 
   r = B;//r指向B中的尾结点 
   
   while(p->next != NULL)
   {
   	if(p->next->data % 2 == 0)//当前判断结点为偶数,则尾插到B中 
   	{
   		q = p-next;//q用来保存当前要删除的结点
   		q->next = q->next;//从A中摘下 （摘下结点不需释放） 
   		q->next = NULL;
   		r->next =  q;//尾插到B中 
   		r = q;//尾指针移动 			
   	} 
   	else
   		p = p->next;//p后移 
   } 
} 

一单链表，其头指针为head，写一算法将该单链表逆置，即最后一个结点变成第一个结点，原来倒数第二个结点编程第二个结点…
从头到尾扫描单链表，将第一个结点的next域置为NULL，将第二个结点的next域指向第一个结点，第三个结点的next域指向第二个结点，等等，直到最后一个结点，使用head指向它

void converts(LinkList head)
{
   LinkNode *p,*q,*r;
   p=head;
   q=p->next;
   p->next=NULL;//第一个结点的next域置为null
   while(q!=NULL)//L无后继结点
   {
       r=q->next;
       q->next=p;//后一结点的next域指向前一个结点
       p=q;
       q=r;
   }
   head=p;//head指向最后一个结点
}

已知head是指向一个带头结点的单链表的头指针，p指向该链表的任一结点，写一算法将p所指向的结点与其后续结点位置交换
若p存在后续结点，看它是否为头结点，如果是，则交换后还要改变该链表的head，如果不是头结点则直接交换，如果p指向最后一个结点，说明其没有后续结点，则不需要交换

void converts(LinkList head)
{
   LinkNode *p,*q,*r;
   p=head;
   q=p->next;
   p->next=NULL;//第一个结点的next域置为null
   while(q!=NULL)//L无后继结点
   {
       r=q->next;
       q->next=p;//后一结点的next域指向前一个结点
       p=q;
       q=r;
   }
   head=p;//head指向最后一个结点
}


void ExchangeNode(LinkList head,ListNode *p)
{
   ListNode *q,*r,*s;
   q=p->next;
   if(q!=NULL)//p不是指向最后一个节点
   {
       if(p==head)
       {
           head=head->next;//head指向原来第二个结点
           s=head->next;//s指向原来第三个结点
           head->next=p;//第二个结点指向第一个
           p->next=s;//第一个结点指向第三个
       }
       else
       {
           r=head;//查找p的前驱结点
           while(r->next!=p)
               r=r->next;
           //r->next=p
           r->next=q;//交换p，q位置
           p->next=q->next;
           q->next=p;
       }
   }
   else
       cin>>"p不存在后继结点，无需交换">>endl;
}

已知两单链表A和B分别表示两个集合，其元素值递增有序，写一算法求A和B的交集C，要求C同样以元素值递增的单链表形式存储

void Bemixed(LinkList a,LinkList b,LinkList c)
{
   ListNode *p,*q,*r,*s;
   c=(ListNode*)malloc(sizeof(ListNode))//c=new ListNode;
   r=c;p=a;q=b;
   while(p!=NULL&&q!=NULL)
   {
       if(p->data<q->data)//A表元素小，则后移一个位置
           p=p->next;
       else if (p->data>q->data)
       {
           q=q->next;
       }
       else//找到一个值相同的结点，在C中生成一个新结点
       {
           s=(ListNode*)malloc(sizeof(ListNode));
           s->data=p->data;
           s->next=NULL;
           r->next=s;//把s结点链接到C表的尾部
           r=s;//r始终指向C表的最后一个结点
           p=p->next;//使p,q指向其后续结点
           q=q->next;
       }
   }
}

有两个顺序表A和B，且都递增有序，写一算法，从A中删除与B中相同的那些元素（A-B）

void SubList(SeqList *A,SeqList B)
{
   int i,j,k;
   k=1;//记住A表的下标位置
   for(i=1;i<=B.length;i++)//**B.length
   {
       for(j=k;j<=A->length;j++)//**A->length
       {
           if(B.data[i]>=A->data[i])
           {
               k=j;break;//用k记住A表的当前位置，以便下次比较从k开始
           }
           else
               continue;
           if(B.data[i]==A->data[k])//相等代表有重复
               DeleteList(A,k);//调用删除函数，删除A中的第k个元素
       }
   }
}

从顺序表中删除具有最小值的元素（假设顺序表中的元素都不相同），并由函数返回被删元素的值，空出的位置由最后一个元素填补

Status SeqList<ElemType>::DeleteMinElem(ElemType &e)
{
   if(length==0)
       return 0;
   else
   {
       int k=0;
       for(int i=1;i<length;i++)
       {
           if(elemd[i]<elems[k])
               k=i;
       }
       e=elems[k];
       length--;
       elems[k]=elems[length];///elems[length]
   }
}

从顺序表中删除具有给定值e的所有元素

void DelElem(ElemType e)
{
   int i=1;
   ElemType x;
   while(i<=length)
   {
       GetElem(i,x);
       if(x==e)
           DeleteElem(i,x);
       else
           i++;
   }
}

在一个顺序表中如果一个数据值重复出现，则留下第一个这样的数据值，并删除其他所有重复的元素，使表中的所有元素的值均不相同

void DelRepElem()
{
   int i=1,j;
   ElemType x,y;
   while(i<=length)
   {
       GeyElem(i,x);
       j=i+1;
       while(j<=length)
       {
           GetElem(j,y);
           if(x==y)
               DeleteElem(j,x);
           else
               j++;
       }
       i++;
   }
}