数据结构学习笔记——线性表的应用

线性表的应用

---

 

线性表的自然连接

---

计算任意两个表的简单自然连接过程讨论线性表的应用。假设有两个表A和B,分别是m1行、n1列和m2行、n2列,它们简单自然连接结果C=A*B（i==j）,其中i表示表A中列号,j表示表B中的列号,C为A和B的笛卡儿积中满足指定连接条件的所有记录组,该连接条件为表A的第i列与表B的第j列相等。
如：
        1 2 3                3 5
A  =  2 3 3         B =  1 6
        1 1 1                3 4
                            
                         1 2 3 3 5
                         1 2 3 3 4
A*B（3==1） =  2 3 3 3 5
                         2 3 3 3 4
                         1 1 1 1 6
数据组织

由于每个表的行数不确定,为此,用单链表作为表的存储结构,每行作为一个数据结点。另外,每行中的数据个数也是不确定的,但由于提供随机查找行中的数据,所以每行的数据采用顺序存储结构,这里用长度为MaxCol的数组存储每行的数据。因此,该单链表中数据结点类型定义如下:

#indefine MaxCol 10                 //最大列数
typedef struct Nodel
{
   ElemType data[MaxCol];
   Struct Nodel *next;                 //指向后继结点
}DList;                                //定义数据结点类型

 

另外,需要指定每个表的行数和列数,为此将单链表的头结点类型定义如下:

typedef struct Node2   /*定义头结点类型*/
{ 
  int Row,Col;         /*行数和列数*/
  DList *next;         /*指向第一个数据结点*/
} HList;

这里的头节点带有附加信息

 

建立线性表

void create(HList *&h)

{     int i,j;  DList *r,*s;
      h=(HList *)malloc(sizeof(HList));
      h->next=NULL;
      r=h;
      printf("表的行数,列数:");
      scanf("%d%d",&h->Row,&h->Col);
      for (i=0;i<h->Row;i++)
     {    
             printf("  第%d行:",i+1);
             r->next=(DList *)malloc(sizeof(DList));
                r = r->next;
             for (j=0;j<h->Col;j++)
                  scanf("%d",&r->data[j]);
      }
      r->next=NULL;    
} 

 

连接表算法

为了实现两个表h1和h2的简单自然连接,先要输入两个表连接的列序号f1和f2,然后扫描单链表h1,对于h1的每个结点,从头至尾扫描单链表h2,若自然连接条件成立,即h1的当前结点*p和h2的当前结点*q满足:

         p->data[f1-1]==q->data[f2-1]

则在新建单链表h中添加一个新结点。

      新建的单链表h也是采用尾插法建表方法创建的。

     

 1 void link(HList *h1,HList *h2,HList *&h)
 2 {       
 3         int f1,f2,i;DList *p=h1->next,*q,*s,*r;
 4         printf("连接字段是:第1个表位序,第2个表位序:");
 5         scanf("%d%d",&f1,&f2);
 6         h=(HList *)malloc(sizeof(HList));
 7         h->Row=0;
 8         h->Col=h1->Col+h2->Col;
 9         h->next=NULL;
         while (p!=NULL)
         {  
            q=h2->next;
            while (q!=NULL)
            {     if (p->data[f1-1]==q->data[f2-1])  /*对应字段值相等*/
          {     s=(DList *)malloc(sizeof(DList)); 
                            /*创建一个数据结点*/
         for (i=0;i<h1->Col;i++)  /*复制表1的当前行*/
                            s->data[i]=p->data[i];
         for (i=0;i<h2->Col;i++)
             s->data[h1->Col+i]=q->data[i];/*复制表2的当前行*/
                         if (h->next==NULL)     h->next=s;
         else  r->next=s;
         r=s;                 /*r始终指向最后数据结点*/
         h->Row++;    /*表行数增1*/
                }
         q=q->next; /*表2下移一个记录*/
            }
          p=p->next;       /*表1下移一个记录*/
      }
      r->next=NULL;/*表尾结点next域置空*/
  }

有序表

---

所谓有序表,是指这样的线性表,其中所有元素以递增或递减方式排列,并规定有序表中不存在元素值相同的元素。在这里仍以顺序表进行存储。

其中只有ListInsert()基本运算与前面的顺序表对应的运算有所差异,其余都是相同的。有序表的ListInsert()运算对应的算法如下:

  

int ListInsert(SqList &L,ElemType e)
{     
       int i=0,j;
       while (i<L.length && L.data[i]<e) i++;
       if (L.data[i]==e) return 0;
       for (j=ListLength(L);j>i;j--)       /*将data[i]及后面元素后移一个位置*/
           L.data[j]=L.data[j-1];
       L.data[i]=e;
       L.length++;   /*顺序表长度增1*/
      return 1;
} //其原理就是根据插入排序而来

例：设计一个算法将两个有序表合并成一个有序表

例：已知三个带头节点的单链表LA，LB和LC中的结点均依元素自小至大非递增排列（每个链表不存在数值相同的点），但可能存在3个链表中都存在的点。编写一算法做如下操作：

使LA仅留下3个表中均包含的数素元素的结点，并且没有数据值相同的结点，并释放LA中所有无用的结点。要求算法时间复杂度为O(m+n+p),m\n\p分别为3个表的长度。

 

一元多项式的计算（非求值）

---

对于一元多项式：

      P=p₀+p₁X+…….+p_nXⁿ

在计算机中，可以用一个线性表来表示:

      P = (p₀, p₁, …，p_n)

但是对于形如

      S(x) = 1 + 3x¹⁰⁰⁰⁰ – 2x²⁰⁰⁰⁰

的多项式，上述表示方法是否合适？

 

一般情况下的一元稀疏多项式可写成

      Pn(x) = p₁x^e1 + p₂x^e2 + ... ... + p_mx^em

其中：pi 是指数为ei 的项的非零系数，

       0≤ e1 < e2 <... ...< em = n

可以下列线性表表示：

  （（p₁, e₁）, (p₂, e₂), ┄, (p_m,e_m) ）

例如:

       P999(x) = 7x³ - 2x¹² - 8x⁹⁹⁹

可用线性表

       ( (7, 3), (-2, 12), (-8, 999) )  

表示

 

因此数据可组织成：

typedef  OrderedLinkList   pol;
// 用带表头结点的有序链表表示多项式

结点的数据元素类型定义为:

typedef struct {      // 项的表示
    float  coef;          // 系数
    int   expn;           // 指数
} term, ElemType;

其应实现的基本运算有：

建立

CreatPolyn ( &P, m )

操作结果：输入 m 项的系数和指数，

          建立一元多项式 P。

 

销毁

DestroyPolyn ( &P )

初始条件：一元多项式 P 已存在。

操作结果：销毁一元多项式 P。

 

打印

PrintPolyn ( &P )

初始条件：一元多项式 P 已存在。

操作结果：打印输出一元多项式 P。

 

项数

PolynLength( P )

初始条件：一元多项式 P 已存在。

操作结果：返回一元多项式 P 中的项数。

 

相加

AddPolyn ( &Pa, &Pb )

初始条件：一元多项式 Pa 和 Pb 已存在。

操作结果：完成多项式相加运算，即：

            Pa = Pa＋Pb，并销毁一元多项式 Pb。

 

相减

SubtractPolyn ( &Pa, &Pb )

初始条件：一元多项式 Pa 和 Pb 已存在。

操作结果：完成多项式相减运算，即：

            Pa = Pa-Pb，并销毁一元多项式 Pb。

 

Status CreatPolyn ( pol &P, int m ) {
   // 输入m项的系数和指数，建立表示一元多项式的有序链表P
   InitList (P); e.coef = 0.0;  e.expn = -1; 
   SetCurElem (h, e);  // 设置头结点的数据元素
   for ( i=1; i<=m; ++i ) {  // 依次输入 m 个非零项
     scanf (e.coef, e.expn);
     if (!LocateElem ( P, e, (*cmp)()) )   
       if ( !InsAfter ( P, e ) )   
          return ERROR;  
   }
  return OK;
} // CreatPolyn

Status AddPolyn ( pol &Pc,  pol &Pa, pol &Pb) {
   // 利用两个多项式的结点构成“和多项式” Pc = Pa＋Pb
                         …  …
   if (DelAfter(Pa, e1))  a=e1.expn   else  a=MAXE;
   if (DelAfter(Pb, e2))  b=e2.expn   else  b=MAXE;
   while (!(a=MAXE && b=MAXE)) {
                …  … 
    }
              …  …
} // AddPolyn

switch (*cmp(e1, e2)) { 
    case -1: {  // 多项式PA中当前结点的指数值小
                          …  …       break;  }
    case 0: {   // 两者的指数值相等
        e1.coef= a.coef + b.coef ;
        if ( a.coef != 0.0 ) InsAfter(Pc, e1); 
                    …  …              break;
    }
    case 1: {  //多项式PB中当前结点的指数值小
                           …  …       break;  }
}

 

约瑟夫环问题

  约瑟夫环（Josephus）问题是由古罗马的史学家约瑟夫（Josephus）提出的，他参加并记录了公元66—70年犹太人反抗罗马的起义。约瑟夫作为一个将军，设法守住了裘达伯特城达47天之久，在城市沦陷之后，他和40名死硬的将士在附近的一个洞穴中避难。在那里，这些叛乱者表决说“要投降毋宁死”。于是，约瑟夫建议每个人轮流杀死他旁边的人，而这个顺序是由抽签决定的。约瑟夫有预谋地抓到了最后一签，并且，作为洞穴中的两个幸存者之一，他说服了他原先的牺牲品一起投降了罗马。
　　约瑟夫环问题的具体描述是：设有编号为1，2，……，n的n(n>0)个人围成一个圈，从第1个人开始报数，报到m时停止报数，报m的人出圈，再从他的下一个人起重新报数，报到m时停止报数，报m的出圈，……，如此下去，直到所有人全部出圈为止。当任意给定n和m后，设计算法求n个人出圈的次序。 

 

解决方法：建立无头节点的循环链表（有头节点亦可）

 

另一种方法（数学方法）时间复杂度o(n)[转]

无论是用链表实现还是用数组实现都有一个共同点：要模拟整个游戏过程，不仅程序写起来比较烦，而且时间复杂
度高达O(nm)，当n，m非常大(例如上百万，上千万)的时候，几乎是没有办法在短时间内出结果的。

为了讨论方便，先把问题稍微改变一下，并不影响原意：

问题描述：n个人（编号0~(n-1))，从0开始报数，报到(m-1)的退出，剩下的人继续从0开始报数。求胜利者的编号
。

我们知道第一个人(编号一定是m%n-1) 出列之后，剩下的n-1个人组成了一个新的约瑟夫环（以编号为k=m%n的人开
始）:
  k  k+1  k+2  ... n-2, n-1, 0, 1, 2, ... k-2
并且从k开始报0。

现在我们把他们的编号做一下转换：
k     --> 0
k+1   --> 1
k+2   --> 2
...
...
k-2   --> n-2
k-1   --> n-1

变换后就完完全全成为了(n-1)个人报数的子问题，假如我们知道这个子问题的解：例如x是最终的胜利者，那么根
据上面这个表把这个x变回去不刚好就是n个人情况的解吗？！！变回去的公式很简单，相信大家都可以推出来：x'
=(x+k)%n

如何知道(n-1)个人报数的问题的解？对，只要知道(n-2)个人的解就行了。(n-2)个人的解呢？当然是先求(n-3)的
情况 ---- 这显然就是一个倒推问题！好了，思路出来了，下面写递推公式：

令f[i]表示i个人玩游戏报m退出最后胜利者的编号，最后的结果自然是f[n]

递推公式
f[1]=0;
f[i]=(f[i-1]+m)%i;  (i>1)

有了这个公式，我们要做的就是从1-n顺序算出f[i]的数值，最后结果是f[n]。因为实际生活中编号总是从1开始，
我们输出f[n]+1

由于是逐级递推，不需要保存每个f[i]，程序也是异常简单：

＃include <stdio.h>
main()
{
  int n, m, i, s=0;
  printf ("N M = "); scanf("%d%d", &n, &m);
  for (i=2; i<=n; i++) s=(s+m)%i;
  printf ("The winner is %d\n", s+1);
}

这个算法的时间复杂度为O(n)，相对于模拟算法已经有了很大的提高。算n，m等于一百万，一千万的情况不是问题了。

====================================================================================================================

另外要说明的是，这个方法只能在o（n）的方法内求出第任意某个出去的人的位置。如果要求出整个出去序列，用这个方法还是o（n^2）的。。求所以出去序列，用线段数可以做到o（nlog(n))..ms没有比这个快的了。。