数据结构与算法分析（6）表的应用实例

    在这里我介绍四个使用表解决实际中的问题的例子，分别是：

    1.多项式的加法和乘法运算；

    2.基数排序；

    3.表的游标实现；

    4.多重表在学生选课系统中的应用。（可选）

    （1）多项式的加法和乘法：

      多项式的加法和乘法有两个实现方式，第一个是用数组来实现，它适合大多数项都有的稠密的多项式；第二个是用链表来实现，它适用于比较稀疏的多项式。但总体而言，还是链表实现的比较好！

      1)下面给出链表实现多项式加法和乘法的范例:

//多项式加法乘法的链表实现 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MaxNodeNum 10
#define MaxMiNum 20; 
 
struct Node{
  int Coefficient;//系数 
  int N;//次方数
  int Element;//元素
  struct Node *Next;    
};
typedef struct Node *Polynomial;
typedef struct Node *Poly_List;

int *RandInt4(int total,int i,int j,int order){
    int *numberGroup=malloc(total*sizeof(int));//用于返回一个指定大小的数组 
    int tempory[j-i+1];//辅助产生随机数的数组。 
    int k;//用于循环遍历 
    int x;//接收产生的随机变量 
    //srand(time(NULL));
    //初始化辅助数组 
    for(k=0;k<=j-i;k++){
        tempory[k]=0;
    }
    for(k=0;k<total;k++){
L:        x=rand()%(j-i+1)+i;//产生从i到j，包括i和j的随机数
        if(tempory[x-i]==0){
          tempory[x-i]=1;
          //当需要产生的数组是无序的则执行： 
          if(order==0){
            numberGroup[k]=x;    
            }
        }else{
            goto L;
        } 
    }
    //当需要产生有序的随机数组时执行: 
    int w=0;
    if(order!=0){
      for(k=0;k<j-i+1;k++){
          if(tempory[k]==1){
              numberGroup[w++]=k+i;
              if(w>=total){
                  break;
              }
          }
      }    
    }
    
    return numberGroup; 
}

Poly_List create(){
    Poly_List list=malloc(sizeof(struct Node));
    list->Next=NULL;
    return list;
}
//初始化一个代表多项式的链，按次方数n排列，并且元素都是一样的 
void initList(Poly_List list,int element){
//每个链表的结点数是任意的，但为了测试方便，这里要求节点数小于10，并且最大次方数为20 
    int nodeNumber=rand()%(MaxNodeNum-3)+4;
    int *tempNumGroup;//次方数的随机数组 
    tempNumGroup=RandInt4(nodeNumber,0,20,1);
    int *coeffNumGroup;//系数的随机数组
    coeffNumGroup=RandInt4(nodeNumber,1,20,0); 
    int i;
    Polynomial tempNode;
    Polynomial ptr=list;
    for(i=0;i<nodeNumber;i++){
        tempNode=malloc(sizeof(struct Node));
        tempNode->Element=element;
        tempNode->Coefficient=coeffNumGroup[i];
        tempNode->N=tempNumGroup[i];
        ptr->Next=tempNode;
        ptr=ptr->Next;
    }
    ptr->Next=NULL; 
}
void initList_MR(Poly_List p){
     initList(p,1);
}
//求两个多项式的和，返回一个链表的头指针 
Poly_List sumPolyList(Poly_List    list1,Poly_List list2){
    Poly_List list=create();
    Polynomial ptr_list=list;
    Polynomial ptr1,ptr2,temp;
    ptr1=list1->Next;
    ptr2=list2->Next;
    while(ptr1!=NULL&&ptr2!=NULL){
        temp=malloc(sizeof(struct Node));
        if(ptr1->N==ptr2->N){
          temp->Coefficient=ptr1->Coefficient+ptr2->Coefficient;
          temp->N=ptr1->N;
          temp->Element=ptr1->Element;
          ptr1=ptr1->Next;
          ptr2=ptr2->Next;    
        }else if(ptr1->N<ptr2->N){
          temp->Coefficient=ptr1->Coefficient;
          temp->N=ptr1->N;
          temp->Element=ptr1->Coefficient;
          ptr1=ptr1->Next;
        }else{
          temp->Coefficient=ptr2->Coefficient;
          temp->N=ptr2->N;
          temp->Element=ptr2->Coefficient;
          ptr2=ptr2->Next;    
        }
        ptr_list->Next=temp;
        ptr_list=ptr_list->Next;
    }
    if(ptr1==NULL){
        while(ptr2!=NULL){
            temp=malloc(sizeof(struct Node));
            temp->N=ptr2->N;
            temp->Element=ptr2->Element;
            temp->Coefficient=ptr2->Coefficient;
            ptr2=ptr2->Next;
            ptr_list->Next=temp;
            ptr_list=ptr_list->Next;
        }
    }else if(ptr2==NULL){
        while(ptr1!=NULL){
            temp=malloc(sizeof(struct Node));
            temp->N=ptr1->N;
            temp->Element=ptr1->Element;
            temp->Coefficient=ptr1->Coefficient;
            ptr1=ptr1->Next;
            ptr_list->Next=temp;
            ptr_list=ptr_list->Next;
        }
    }
    ptr_list->Next=NULL;
    return list;
}
int exsist(Poly_List    list,int N){
    Polynomial ptr=list->Next;
    while(ptr!=NULL){
        if(ptr->N==N){
            return 1;
        }
        ptr=ptr->Next;
    }
    return 0;
}
Polynomial findInsertPosition(Poly_List    list,int N){
    Poly_List ptr1=list->Next;
    Poly_List ptr2=list;
    while(ptr1!=NULL){
        //如果元素存在，则不需要插入，直接返回元素所在位置 
        if(ptr1->N==N){
            return ptr1;
        //如果N的值小于当前结点的值，则插入在当前结点的前面 
        }else if(ptr1->N>N){
            return ptr2;
        }//如果N的值大于当前结点的值，则看下一个元素，如果下一个元素为空，则返回最后一个元素 
        ptr2=ptr1;
        ptr1=ptr2->Next;
    }
    return ptr2;
} 
void insertIntoList(Poly_List list,int N,int C){
    Polynomial temp;
    Poly_List ptr1=list->Next;
    Poly_List ptr2=list->Next;
    if(list->Next==NULL){
        temp=malloc(sizeof(struct Node));
        temp->Coefficient=C;
        temp->N=N;
        list->Next=temp;
        temp->Next=NULL;
    }else if(ptr1!=NULL){
        if(exsist(list,N)){
            ptr2=findInsertPosition(list,N);
            ptr2->Coefficient+=C;
        }else{
            ptr2=findInsertPosition(list,N);
            temp=malloc(sizeof(struct Node));
            temp->N=N;
            temp->Coefficient=C;
            temp->Next=ptr2->Next;
            ptr2->Next=temp;
        }        
    }
}
void printPolyList(Poly_List list){
    Polynomial ptr=list->Next;
    while(ptr!=NULL){
        if(ptr!=list->Next){
          printf("+%dx^%d",ptr->Coefficient,ptr->N);    
        }else{
          printf("%dx^%d",ptr->Coefficient,ptr->N);    
        }        
        ptr=ptr->Next;
    }
} 
//求多项式的乘积 
Poly_List subPolyList(Poly_List    list1,Poly_List list2){
    Poly_List list=create();
    Poly_List ptr1=list1->Next;
    Poly_List ptr2=list2->Next;
    int list1_noNum=0;
    int list2_noNum=0;
    while(ptr1!=NULL){
        ptr1=ptr1->Next;
        list1_noNum++;
    }
    while(ptr2!=NULL){
        ptr2=ptr2->Next;
        list2_noNum++; 
    }
    int *list1_NnumGroup=malloc(sizeof(int)*list1_noNum);
    int *list1_CnumGroup=malloc(sizeof(int)*list1_noNum);
    int *list2_NnumGroup=malloc(sizeof(int)*list2_noNum);
    int *list2_CnumGroup=malloc(sizeof(int)*list2_noNum);
    ptr1=list1->Next;
    ptr2=list2->Next;
    int i=0;
    while(ptr1!=NULL){
        list1_NnumGroup[i]=ptr1->N;
        list1_CnumGroup[i]=ptr1->Coefficient;
        i++;
        ptr1=ptr1->Next;
    }
    i=0;
    while(ptr2!=NULL){
        list2_NnumGroup[i]=ptr2->N;
        list2_CnumGroup[i]=ptr2->Coefficient;
        i++;
        ptr2=ptr2->Next;
    }
    int k,w=0;
    //作乘法得到的多项式的结点数 
       int listNN=list1_noNum*list2_noNum;
    int *list_NnumGroup=malloc(sizeof(int)*listNN);
    int *list_CnumGroup=malloc(sizeof(int)*listNN);
    for(i=0;i<list1_noNum;i++){
        for(k=0;k<list2_noNum;k++){
            list_NnumGroup[w]=list1_NnumGroup[i]+list2_NnumGroup[k];
            list_CnumGroup[w]=list1_CnumGroup[i]*list2_CnumGroup[k];            
            w++;
        }
    }
    free(list1_CnumGroup);
    free(list1_NnumGroup);
    free(list2_CnumGroup);
    free(list2_NnumGroup);
    for(i=0;i<listNN;i++){
        insertIntoList(list,list_NnumGroup[i],list_CnumGroup[i]);
    }
    return list; 
} 
int main(){
  srand(time(NULL));
  Poly_List p1=create();
  Poly_List p2=create();
  //初始化两个多项式链表
  initList_MR(p1);
  initList_MR(p2);
  printf("第一个多项式为:
");
  printPolyList(p1);
  printf("
第二个多项式为:
"); 
  printPolyList(p2);
  printf("
");
  Poly_List Sum_p1_p2;
  Poly_List Sub_p1_p2;
  Sum_p1_p2=sumPolyList(p1,p2);
  Sub_p1_p2=subPolyList(p1,p2);
  printf("
这两个多项式之和为:
");
  printPolyList(Sum_p1_p2);
  printf("
这两个多项式的乘积为:
");
  printPolyList(Sub_p1_p2);    
  return 0;
} 

       2)用数组实现多项式的范例:

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define MaxDegree 40//定义多项式的最大的次数为40,最小的为0
#define MaxCoffe 30//定义系数为的最大值为30 
struct Node{
  int CoeffArray[MaxDegree+1];
  int HighPower; 
};//每个结点代表一个多项式 
typedef struct Node *Polynomial;
int *RandInt4(int total,int i,int j,int order){
    int *numberGroup=malloc(total*sizeof(int));//用于返回一个指定大小的数组 
    int tempory[j-i+1];//辅助产生随机数的数组。 
    int k;//用于循环遍历 
    int x;//接收产生的随机变量 
    //srand(time(NULL));
    //初始化辅助数组 
    for(k=0;k<=j-i;k++){
        tempory[k]=0;
    }
    for(k=0;k<total;k++){
L:        x=rand()%(j-i+1)+i;//产生从i到j，包括i和j的随机数
        if(tempory[x-i]==0){
          tempory[x-i]=1;
          //当需要产生的数组是无序的则执行： 
          if(order==0){
            numberGroup[k]=x;    
            }
        }else{
            goto L;
        } 
    }
    //当需要产生有序的随机数组时执行: 
    int w=0;
    if(order!=0){
      for(k=0;k<j-i+1;k++){
          if(tempory[k]==1){
              numberGroup[w++]=k+i;
              if(w>=total){
                  break;
              }
          }
      }    
    }
    
    return numberGroup; 
}
void zeroPolymial(Polynomial p){
    int i;
    for(i=0;i<=MaxDegree;i++)
      p->CoeffArray[i]=0;
    p->HighPower=0;
} 
void printMulti(Polynomial p){
    int i;
    int flag=0;
    for(i=0;i<=p->HighPower;i++){
        if(p->CoeffArray[i]!=0){
          if(flag==1){
            printf("+");
            }
          if(i!=(p->HighPower-1)){
             printf("%dx^%d",p->CoeffArray[i],i);
             flag=1;
          }else{
             printf("%d^%d", p->CoeffArray[i],i);
          }
        }
    }
}
Polynomial initMulti(){
    Polynomial p=malloc(sizeof(struct Node));
    zeroPolymial(p); 
    int r=rand()%7+4;//在一个多项式中含有r个元素
    int *temp=RandInt4(r,0,20,0);
    int i;
    for(i=0;i<r;i++){
        p->CoeffArray[temp[i]]=rand()%MaxCoffe+1;
        if(p->HighPower<temp[i]){
            p->HighPower=temp[i];
        }
    }
    return p;
}
Polynomial sumOf(Polynomial p1,Polynomial p2){
    Polynomial p;
    p=malloc(sizeof(struct Node));
    zeroPolymial(p);
    int a=p1->HighPower;
    int b=p2->HighPower;
    p->HighPower=a>b?a:b;
    int i;
    for(i=p->HighPower;i>=0;i--){
        p->CoeffArray[i]=p1->CoeffArray[i]+p2->CoeffArray[i];
    }    
    return p;
}
Polynomial subOf(Polynomial p1,Polynomial p2){
    Polynomial p;
    int i,j;
    p=malloc(sizeof(struct Node));
    zeroPolymial(p);
    p->HighPower=p1->HighPower+p2->HighPower;        
    if(p->HighPower>MaxDegree){
        printf("多项式最高项溢出,次数为%d",p->HighPower);
    }else{
        for(i=0;i<=p1->HighPower;i++){
            if(p1->CoeffArray[i]==0){
                continue;
            }
            for(j=0;j<=p2->HighPower;j++){
                p->CoeffArray[i+j]+=p1->CoeffArray[i]*p2->CoeffArray[j];
            }
        }
    }
    return p;
}

int main(){
    srand(time(NULL));
    Polynomial multItem1;
    Polynomial multItem2;
    multItem1=initMulti();
    multItem2=initMulti();
    printf("第一个多项式为:
");
    printMulti(multItem1);
    printf("
第二个多项式为:
");
    printMulti(multItem2);
    printf("
这两个多项式的和是:
");
    printMulti(sumOf(multItem1,multItem2));
    printf("
这两个多项式的乘积为
");
    printMulti(subOf(multItem1,multItem2));
    return 0;
} 

 

      (2)使用链表的第二个例子叫做基数排序（radix sort）。基数排序有时也成为卡式排序（card sort），因为直到现代计算机出现之前，它一直用于老式穿孔卡的排序。

      1)在介绍基数排序之前，先介绍一下桶式排序:

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

int *RandInt4(int total,int i,int j,int order){
    int *numberGroup=malloc(total*sizeof(int));//用于返回一个指定大小的数组 
    int tempory[j-i+1];//辅助产生随机数的数组。 
    int k;//用于循环遍历 
    int x;//接收产生的随机变量 
    //srand(time(NULL));
    //初始化辅助数组 
    for(k=0;k<=j-i;k++){
        tempory[k]=0;
    }
    for(k=0;k<total;k++){
L:        x=rand()%(j-i+1)+i;//产生从i到j，包括i和j的随机数
        if(tempory[x-i]==0){
          tempory[x-i]=1;
          //当需要产生的数组是无序的则执行： 
          if(order==0){
            numberGroup[k]=x;    
            }
        }else{
            goto L;
        } 
    }
    //当需要产生有序的随机数组时执行: 
    int w=0;
    if(order!=0){
      for(k=0;k<j-i+1;k++){
          if(tempory[k]==1){
              numberGroup[w++]=k+i;
              if(w>=total){
                  break;
              }
          }
      }    
    }   
    return numberGroup; 
}
void *bucketSort(int *p,int low,int high,int total){
    int *bucket=malloc(sizeof(int)*(high-low+1));
    int i;
    //初始化桶，桶里的数值将代表元素出现的次数(适用于有重复元素的情况)，下标代表响应的元素 
    for(i=0;i<(high-low+1);i++){
          bucket[i]=0;
    }
    for(i=0;i<total;i++){
        bucket[p[i]]+=1;
    }
    int j,w=0;
    for(i=0;i<(high-low+1);i++){
        //虽然不会有重复数据，但还是在这里实现允许重复数据的例子 
        for(j=0;j<bucket[i];j++){
            p[w]=i;
            w++;
        }
    }    
}
int main(){
      int *numGroup=RandInt4(40,0,104,0);
      int i;
    printf("未排序的数组是:
");
    for(i=0;i<40;i++){
        printf("%3d  ",numGroup[i]);
        if((i+1)%10==0){
            printf("
"); 
        }
    }
    bucketSort(numGroup,0,105,40);
    printf("排过序的数组是:
");
    for(i=0;i<40;i++){
        printf("%3d  ",numGroup[i]);
        if((i+1)%10==0){
            printf("
"); 
        }
    }
} 

      2)基数排序是桶式排序的推广，当数的取值范围非常大的时候，进行多趟桶排序以减少桶空间的使用：

#include<stdio.h>
#include<stdlib.h>
#define bucketSize 10

struct Node{
  int Element;
  struct Node *Next;    
};
typedef struct Node *Number;
typedef struct Node *NumList;

int pow(int x,int N){
    if(N==0){
        return 1;
    }else{
        return pow(x,N-1)*x;
    }    
}
int *RandInt4(int total,int i,int j,int order){
    int *numberGroup=malloc(total*sizeof(int));//用于返回一个指定大小的数组 
    int tempory[j-i+1];//辅助产生随机数的数组。 
    int k;//用于循环遍历 
    int x;//接收产生的随机变量 
    //srand(time(NULL));
    //初始化辅助数组 
    for(k=0;k<=j-i;k++){
        tempory[k]=0;
    }
    for(k=0;k<total;k++){
L:        x=rand()%(j-i+1)+i;//产生从i到j，包括i和j的随机数
        if(tempory[x-i]==0){
          tempory[x-i]=1;
          //当需要产生的数组是无序的则执行： 
          if(order==0){
            numberGroup[k]=x;    
            }
        }else{
            goto L;
        } 
    }
    //当需要产生有序的随机数组时执行: 
    int w=0;
    if(order!=0){
      for(k=0;k<j-i+1;k++){
          if(tempory[k]==1){
              numberGroup[w++]=k+i;
              if(w>=total){
                  break;
              }
          }
      }    
    }   
    return numberGroup; 
}
void initNumList(NumList bucketlist[]){
    int i;
    for(i=0;i<bucketSize;i++){
        bucketlist[i]=malloc(sizeof(struct Node));
        bucketlist[i]->Next=NULL;
    }
}
void insertIntoNumList(int x,NumList list){
    Number temp=malloc(sizeof(struct Node));
    temp->Element=x;
    NumList ptr=list;
    while(ptr->Next!=NULL){
        if(x<=ptr->Next->Element){
            temp->Next=ptr->Next;
            ptr->Next=temp;
            return; 
        }else if(x>ptr->Next->Element){
            ptr=ptr->Next;
        }
    }
    //当ptr的下一个结点为空时 
    ptr->Next=temp;
    temp->Next=NULL;
}
void printBucketNumberGroup(NumList    bucklist[]){
  int i;
  NumList ptr;
  for(i=0;i<bucketSize;i++){
      ptr=bucklist[i]->Next;
      printf("桶%d里存的数据有:",i);
      while(ptr!=NULL){
        printf("%4d  ",ptr->Element);
        ptr=ptr->Next;    
      }
      printf("
");
    }
}
void cardSort(int *p,int Max,int total){
    NumList bucklist[bucketSize];
    initNumList(bucklist);
    int ranks;//记录基数排序所需的趟数 
    int i,j;
    int temp;//记录基数排序过程中每个元素的末尾数字 
    for(ranks=-1;Max>0;ranks++){
        Max/=bucketSize;
    }
    //printf("此次基数排序共分%d趟进行:
",ranks);
    for(i=0;i<total;i++){
        temp=(p[i]/1)%10;
        //printf("%d的个位数字是:%d  
",p[i],temp);
        insertIntoNumList(p[i],bucklist[temp]);
    }
    //printf("第%d次桶排序的桶存的数据为:
",1);    
    //printBucketNumberGroup(bucklist);
    NumList ptr,ptrForFree;
    int element;
    for(i=2;i<=ranks;i++){
        for(j=0;j<bucketSize;j++){
             ptr=bucklist[j];       
            while(ptr->Next!=NULL){
                element=(ptr->Next->Element);
                temp=(element/pow(10,i-1))%10;
                //如果此元素的对应位数的下标不属于此桶 
                if(temp!=j){
                    ptrForFree=ptr->Next;
                    ptr->Next=ptr->Next->Next;
                    free(ptrForFree);
                    //插入另一个桶 
                      insertIntoNumList(element,bucklist[temp]);
                }else{
                    ptr=ptr->Next;                    
                }
            }
        }
    //printf("第%d次桶排序的桶存的数据为:
",i);    
    //printBucketNumberGroup(bucklist);
    }

    j=0;
    for(i=0;i<bucketSize;i++){
      ptr=bucklist[i]->Next;
      while(ptr!=NULL){
        p[j++]=ptr->Element;
        //printf("第%d个数为%d
",j,p[j-1]);
        if(j>total){
            printf("数组溢出，大小最大为%d,出现错误
",total);
            exit(0);
        }    
        ptr=ptr->Next;    
      }
    }
}
int main(){
      int *numGroup=RandInt4(100,0,10000,0);
    int i;
    printf("未排序的数组是：
");
      for(i=0;i<100;i++){
          printf("%4d  ",numGroup[i]);
          if((i+1)%10==0){
              printf("
");
          }
    }
    cardSort(numGroup,10000,100);
    printf("排过序的数组是：
");
    for(i=0;i<100;i++){
          printf("%4d  ",numGroup[i]);
          if((i+1)%10==0){
              printf("
");
          }
    } 
    return 0;
} 

      本实例的桶数可以任意指定，多少都行，而且也不限制数的大小。缺点是产生随机数组的过程十分消耗资源。

      (3)许多语言并不支持指针。如果需要链表而又不能使用指针，那么就必须使用另外的实现方法。我们将描述这种方法，并称为游标（cursor）实现法。

      在链表的指针实现的过程中有两个重要的特点：

      1)数据存在一组结构体中。每个结构体包含有数据以及指向下一个结构体的指针。

      2)一个新的结构体可以通过调用malloc从系统全局内存中得到，并可通过free而被释放掉。

     游标法必须能够模仿实现这两条特性。

     下面给出用游标法写出的链表例程:

#include<stdio.h>
#define SpaceSize 40

typedef int PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;

struct Node{
    int Element; 
    int flag;//记录元素出现的次数 
    Position Next;//Next指针指向的不是具体的结点的首地址，而是结点的下标 
};
int *RandInt4(int total,int i,int j,int order){
    int *numberGroup=malloc(total*sizeof(int));//用于返回一个指定大小的数组 
    int tempory[j-i+1];//辅助产生随机数的数组。 
    int k;//用于循环遍历 
    int x;//接收产生的随机变量 
    srand(time(NULL));
    //初始化辅助数组 
    for(k=0;k<=j-i;k++){
        tempory[k]=0;
    }
    for(k=0;k<total;k++){
L:        x=rand()%(j-i+1)+i;//产生从i到j，包括i和j的随机数
        if(tempory[x-i]==0){
          tempory[x-i]=1;
          //当需要产生的数组是无序的则执行： 
          if(order==0){
            numberGroup[k]=x;    
            }
        }else{
            goto L;
        } 
    }
    //当需要产生有序的随机数组时执行: 
    int w=0;
    if(order!=0){
      for(k=0;k<j-i+1;k++){
          if(tempory[k]==1){
              numberGroup[w++]=k+i;
              if(w>=total){
                  break;
              }
          }
      }    
    }
    
    return numberGroup; 
}
//编译时预先分配的结点数组 
struct Node CursorSpace[SpaceSize];
//CursorSpace[0]是表头指针 
static void InitialCursor(void){
    int i;
    for(i=0;i<SpaceSize;i++){
        CursorSpace[i].Next=i+1;
    }
    CursorSpace[i].Next=0;
} 
static Position CursorAlloc(void){
    Position p;
    p=CursorSpace[0].Next;
    CursorSpace[0].Next=CursorSpace[p].Next;
    CursorSpace[p].Next=0;
    return p;//当p的值为0时说明没有空间可用了    
} 
static void CursorFree(Position p){
    CursorSpace[p].Next=CursorSpace[0].Next;
    CursorSpace[0].Next=p;
}
void InitList(List *L){
    PtrToNode p=CursorAlloc();
    //新建的结点需要指向头结点 
    CursorSpace[p].Next=0;
    *L=p;
}
int IsLast(Position p,List L){
    return CursorSpace[p].Next==0;
}
Position FindPrevious(int x,List L){
    Position p;
    p=L;
    Position temp=CursorSpace[p].Next;
    while((temp!=0)&&(CursorSpace[temp].Element!=x)){
        p=temp;
        temp=CursorSpace[temp].Next;
    }
    return p;//当p为0时说明没有找到    
} 
Position Find(int x,List L){
    Position p;
    p=CursorSpace[L].Next;
    while((p!=0)&&(CursorSpace[p].Element!=x)){
        p=CursorSpace[p].Next;
    }
    return p;//当p为0时说明没有找到    
}
void Delete(int x,List L){
    Position p,TmpCell;
    p=FindPrevious(x,L);
    //处理要删除的元素的出现在表中很多次的情况
    TmpCell=CursorSpace[p].Next;
    int flag=CursorSpace[TmpCell].flag; 
    if(flag>1){
        CursorSpace[TmpCell].flag--;
        return;
    }
    if(!IsLast(p,L)){//如果是最后一个的话，肯定没找着，p的下一个为头结点，此时不需要执行删除操作 
      TmpCell=CursorSpace[p].Next;
      CursorSpace[p].Next=CursorSpace[TmpCell].Next;
      CursorFree(TmpCell);    
    }
} 
//插入操作将新元素插到p的后面 
void Insert(int x,List L,Position p){
    Position TmpCell;
    TmpCell=CursorAlloc();
    if(TmpCell==0){
        printf("空间已经使用完！
");
        exit(0);
    }
    CursorSpace[TmpCell].Element=x;
    CursorSpace[TmpCell].flag=1; 
    CursorSpace[TmpCell].Next=CursorSpace[p].Next;
    CursorSpace[p].Next=TmpCell;
}
Position FindInsertPosition(int x,List L){
    Position p=Find(x,L);
    int temp;
    //如果没有找到这个元素，则需要返回一个插入的位置 
    if(p==0){
       p=L;
       //当p的下一个元素不是头元素时 
       while((temp=CursorSpace[p].Next)!=0){
            if(CursorSpace[temp].Element<x){
            p=CursorSpace[p].Next;
            }
         else if(CursorSpace[temp].Element>x){
               break;
            }//由于前面已经判断过x不在这个表中，所以只有大于小于两种可能 
       }
       //当p的下一个元素是头元素时 
       return p;    
    }else{
        CursorSpace[p].flag++;
        //插入一个已经存在的元素，不需要再执行申请新元素的插入操作 
        return 0;
    }
}
void InsertIntoList(int x,List L){
    Position p=FindInsertPosition(x,L);
    //如果p！=0说明找到了一个插入的位置 
    if(p!=0){
      Insert(x,L,p);
    }//p等于0的情况出现在插入一个在表中已经存在的元素时 
}
void printList(List list){
    Position p=list;
    Position temp;
    int i;
    int w=0; 
    while((temp=CursorSpace[p].Next)!=0){
        //printf("%d",CursorSpace[temp].flag);
         for(i=0;i<CursorSpace[temp].flag;i++){
             printf("%3d",CursorSpace[temp].Element);
             w++;
             if(w%30==0){
                 printf("
");
             }
         }
         p=CursorSpace[p].Next;
    }
}
int main(){
    InitialCursor();
    List a_list;
    InitList(&a_list);
    int *a_tempNumGroup;
    a_tempNumGroup=RandInt4(35,0,99,0); 
    int i; 
    printf("即将插入到游标模式组成的链表中的元素组是:
");
    for(i=0;i<35;i++){
        printf("%3d",a_tempNumGroup[i]);
        if((i+1)%30==0){
            printf("
");
        }
    }
    for(i=0;i<35;i++){
        //printf("这次要插入的有：%d
",a_tempNumGroup[i]);
        InsertIntoList(a_tempNumGroup[i],a_list);
        //printList(a_list);
    }
    printf("
下面是功能测试部分:"); 
    printf("
链表中的元素是：
");
    printList(a_list);
    int n;
    printf("
请再输入一个数，执行删除操作:
",&n);
    scanf("%d",&n);
    getchar();
    Delete(n,a_list);
    printf("删除一个元素后的链表是:
"); 
    printList(a_list);
    printf("
请再输入一个数，执行插入链表中已经存在数操作:
",&n);
    scanf("%d",&n);
    getchar();    
    InsertIntoList(n,a_list);
    printf("添加一个元素已存在元素后的链表是:
"); 
    printList(a_list);
    printf("
请再输入一个数，执行删除链表中已经存在很多次的元素的操作:
",&n);
    scanf("%d",&n);
    getchar();    
    Delete(n,a_list);
    printf("删除一个元素已存在很多次元素后的链表是:
"); 
    printList(a_list);          
} 

      (4)我们的最后一个例子阐述链表更复杂的应用。大学需要生成两种不同的报告，一个是每个班级的所有学生，一个是每个学生所在的班级（可能在很多个班级里）。我们用多重表来实现：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>

struct Student;
struct Class;
struct StuCla;

struct Student{
  char Name[10];
  struct StuCla *FirstStu;//指向的第一个学生    
};
struct Class{
    char Name[10];
    struct StuCla *FirstStu;//本班的第一个学生 
};
struct StuCla{
    char Stu_name[10];//学生的姓名
    char Class_name[10];//班级的名称
    int cla;//用于排序 
    int stu; //用于排序 
    struct Student *BelongStudent;//用于最后一个结点，指向学生主结点 
    struct Class   *BelongClass;//用于最后一个结点，指向班级主结点 
    struct StuCla  *SameCNextStudent;//用于同班同学那条链 
    struct StuCla  *SameSNextStudent;//用于一个学生所选的课程 
};
typedef    struct StuCla *PtrToNode;
//在这里进行测试，为了简单，只有5个班级，5名学生。
struct Class classes[5];
struct Student student[5];
//初始化所有的班级和学生 
static void Initial(){
    int i;
    char str1[10];
    char str2[10];
    char temp[2];
    for(i=0;i<5;i++){
      strcpy(str1,"class");        
      strcpy(str2,"student");
      itoa(i+1,temp,10);
      strcat(str1,temp);
      strcat(str2,temp);
      //printf("%s,%s
",str1,str2);
      strcpy(classes[i].Name,str1);
      strcpy(student[i].Name,str2);
      classes[i].FirstStu=NULL;
      student[i].FirstStu=NULL;    
    }
}
static void InsertIntoDoubleList(int stuN,int claN){
    PtrToNode temp=malloc(sizeof(struct StuCla));
    strcpy(temp->Stu_name,student[stuN].Name);
    strcpy(temp->Class_name,classes[claN].Name);
    temp->cla=claN;
    temp->stu=stuN; 
    temp->BelongStudent=NULL;
    temp->BelongClass=NULL;
    temp->SameCNextStudent=NULL;
    temp->SameSNextStudent=NULL;
    
    //让学生主结点指向新生成的结点
    PtrToNode Pre_ptr=NULL;
    PtrToNode ptr=student[stuN].FirstStu;
    //处理第一次插入的情况 
    if(ptr==NULL){
        student[stuN].FirstStu=temp;
        temp->BelongStudent=&student[stuN];
        goto L;
    }
    while(ptr!=NULL){
        //插在当前结点之前 
        if(ptr->cla>temp->cla){
          temp->SameSNextStudent=ptr;
          //如果当前结点是主结点后的第一个结点 
          if(ptr==student[stuN].FirstStu){
              student[stuN].FirstStu=temp;
              goto L;
            }else{ 
            Pre_ptr->SameSNextStudent=temp;
            goto L; 
            }
        }else if(ptr->cla<temp->cla){
          //如果不是第一个，找到它前面的一个。
           Pre_ptr=ptr;
          ptr=ptr->SameSNextStudent;    
        }else{
          printf("学生%d重复插入班级%d
",stuN,claN);
          return;
        } 
    }
    //用来处理插入到末尾的情况 
    Pre_ptr->SameSNextStudent=temp;
    Pre_ptr->BelongStudent=NULL;
    temp->BelongStudent=&student[claN];
    
    //让班级主结点指向新生成的结点
L:  ptr=classes[claN].FirstStu;
    //处理第一次插入的情况 
    if(ptr==NULL){
        classes[claN].FirstStu=temp;
        temp->BelongClass=&classes[claN];
        return;
    }
    while(ptr!=NULL){
        //插在当前结点之前 
        if(ptr->stu>temp->stu){
          temp->SameCNextStudent=ptr;
          //如果当前结点是主结点后的第一个结点 
          if(ptr==classes[claN].FirstStu){
              classes[claN].FirstStu=temp;
              return;
            }else{
                //如果不是第一个，找到它前面的一个。 
            Pre_ptr->SameCNextStudent=temp;
            return;
            }
        }else if(ptr->stu<temp->stu){
           Pre_ptr=ptr;
          ptr=ptr->SameCNextStudent;    
        }else{
            printf("学生%d重复插入班级%d
",stuN,claN);
            return;
        } 
    }
    //用来处理插入到末尾的情况 
    Pre_ptr->SameCNextStudent=temp;
    Pre_ptr->BelongClass=NULL;
    temp->BelongClass=&classes[claN];   
} 
static void printStudent(int N){
  printf("学生%d所选的班级有:",N+1);
  PtrToNode ptr=student[N].FirstStu;
  while(ptr!=NULL){
    printf("%10s",ptr->Class_name);    
    if(ptr->BelongStudent!=NULL){
        printf("末尾");
    }
    ptr=ptr->SameSNextStudent;
  }    
  printf("
");
}
static void printClass(int N){
  printf("班级%d所有的学生有:",N+1);
  PtrToNode ptr=classes[N].FirstStu;
  while(ptr!=NULL){
    printf("%10s",ptr->Stu_name);
    if(ptr->BelongClass!=NULL){
        printf("末尾");
    }
    ptr=ptr->SameCNextStudent;    
  }    
  printf("
");
}
static void printInformation(){
    printf("先输出所有学生所选的班级:
");
    int i;
    for(i=0;i<5;i++){
        printStudent(i);
    }
    printf("再输出所有班级里都有什么学生:
"); 
    for(i=0;i<5;i++){
        printClass(i);
    }
}
int main(){
    srand(time(NULL)); 
    Initial();   
     int StuAndCla[5][5];
    int i;
    int j;
    int w;
    for(i=0;i<5;i++){
        for(j=0;j<5;j++){
            StuAndCla[i][j]=0; 
        }
    } 
    for(w=0;w<20;w++){
        i=rand()%5;
        j=rand()%5;
        if(StuAndCla[i][j]==0){
          StuAndCla[i][j]=1;
          //printf("学生%d选了班级%d",i+1,j+1);
          InsertIntoDoubleList(i,j);
          //printInformation();     
          //printf("
"); 
        }
    }
    printInformation();    
}

      这样每个学生和一个班级的对应关系将转化为一个结点存在此二重链表中，而班级和学生的每一个子链的最后一个一个都指向该班级或学生，这个功能是为了这种情况：找某个同学所在的班级。这个功能是在输出这个结点时，如果它指向班级或者学生的头指针，则后面会加“末尾”两个字。