线性表总结

2019/03/25 22:17
阅读数 13

#线性表总结

线性表的定义:线性表是具有相同数据类型的n个数据元素的有限序列。n为表长,当n = 0时,为空表。
线性表公式表示:L = (a1,a2,a3.......an), a1 为表头元素,an为表尾元素。除了第一个元素,每个元素都有且仅有一个直接前驱,除了最后一个元素,每个元素有且仅有一个直接后继。
线性表的特点:有限个数;逻辑上有顺序性;每个表元素都是单个元素;表元素类型皆相同;元素具有抽象性。

线性表与链表/顺序表之间的区别:线性表是一种逻辑结构,表示元素之间一一对应的关系;链表和顺序表指的是存储结构。
在计算机内,可以用不同的方式来表示线性表,最简单最常用的方式是顺序存储结构—顺序表,而链表则经常被用来表示非线性的数据结构,也是一种常用的表示线性表的方法。

顺序表:线性表的顺序存储被称为顺序表,它是一组地址连续的顺序存储单元,依次存储线性表中的数据元素。注意顺序存储是一种读写方式,不是存储方式,有别于顺序存储。线性表支持随机存取的顺序存储结构。
顺序表的优点:1:存储密度高;2:元素可以随机读取;3:存储位置可以简单的使用公式来表示。

链表:由于顺序表的插入删除元素操作需要移动大量的元素,影响运行效率,所以引入了链式存储,链式存储通过“链”建立起数据元素之间的逻辑关系,只需要修改指针进行插入、删除操作。分为单链表和双链表。
链表的优点:1:适合随机的插入和删除操作;2:存储空间大小不需要提前设定;3:可以进行动态存储。

顺序表和链表的比较:
1:存取,链表只能从表头开始顺序存取元素;顺序表可以随机存取
2:存储方式,顺序表相邻存储;链表物理存储位置不一定相邻,其逻辑关系是通过指针来链接的
3:顺序表在静态分配时,不可改变内存大小,可能会造成溢出,动态分配时,插入和删除需要移动大量的元素,效率很低。但链表只在需要的时候申请内存,操作灵活

单链表:线性表的链式存储称为单链表,它不是连续的存储空间,元素之间是通过指针进行联系。我们通常使用“头指针”来标识一个单链表,当头指针为“NULL”时表示一个空表,此外,为了操作上的方便,在单链表第一个结点之前附加一个结点,称之为“头结点”,头结点的数据域可以不设任何信息,也可以记录表长等相关信息。但是不管带不带头结点,头指针始终指向链表的第一个结点。注意头结点不计入表长。
特点:非随机存取,不能直接从表中找到特定的结点,需要从表头开始遍历,依次查找
双链表:单链表结点中只有一个指向其后继的指针,这使得单链表只能从头到尾依次顺序的向后遍历,若要访问某个结点的前驱,只能从头开始遍历,访问后继结点的时间复杂度为O(1),访问前驱结点的时间复杂度为O(n);为克服以上缺点,引入双链表,一个结点含有两个指针,分别指向其前驱结点和后继结点。 

1. 代码段1简介:表连接运算算法

1.1. 代码1

void LinkTabl  (HList *h,HList*h2,HList *&h)                                                                                                                           //1
 {                                                                                                                                                                                             //2
      inti,j,k;                                                                                                                                                                                //3
      DList *p=h1->next, *q, *s, *r;                                                                                                                                              //4
      print("连接字段是:第1个表序号,第2个表序号:");                                                                                                                 //5
      scanf("%d%d" ,&i,&j);                                                                                                                                                        //6
      h=(HList * )mallolsizeo(t HList));                                                        //创建结果表头结点                                                   //7
      h->Row=0;                                                                                        //置行数为0                                                               //8
      h ->Col=h1- >Col+h2- >Col;                                                              //置列数为表1和表2的列行数                                    //9
      h->next=NULL;                                                                                  //置 next 域为 NULL                                                  //10
      while (p!= NULL)                                                                               //扫描表1                                                                  //11
      {                                                                                                                                                                                        //12       
          q=h2->next;                                                                                   //q指向表2的首结点                                                 //13
          while (q!= NULL)                                                                            //扫描表2                                                                 //14
          {                                                                                                                                                                                    //15
              if(p->data[i-1]==q ->data[j- 1])                                                   //对应字段值相等                                                     //16
              {                                                                                                                                                                                //17
                  s=(DList * )malloc (sizeof(DList));                                          //创建一个数据结点S                                                //18
                  for (k=0;k<h1-> Col;k++ )                                                      //复制表1的当前行                                                    //19
                  s-> data[k]=p-> data[k];                                                                                                                                      //20
                  for (k=0;k<h2 -> Col;k++ )                                                     //复制表2的当前行                                                     //21
                  s-> data[h1->Col+k]=q-> data[k];                                                                                                                        //22
                  if (h-> next== NULL)                                                              //若插人的是第一个数据结点                                      //23
                      h-> next=s;                                                                        //将s结点插人到头结点之后                                        //24
                  else                                                                                       //若插人其他数据结点                                                 //25
                      r->next=s;                                                                          //将s结点插人到结点r后                                              //26       
                  r=s;                                                                                        //r始终指向尾结点                                                       //27
                  h-> Row++ ;                                                                           //表行数增1                                                                  //28
              }                                                                                                                                                                                    //29
              q=q->next;                                                                                 //表2后移一个结点                                                       //30
          }                                                                                                                                                                                        //31
              p=p-> next;                                                                                    //表1后移一个结点                                                       //32
      }                                                                                                                                                                                            //33
      r-> next= NULL;                                                                                 //表尾结点的next域置空                                               //34
  }                                                                                                                                                                                                //35
(课本P64)

1.2. 不懂得地方

    第14行到第31行。问题:功能不懂。
    我对代码的理解:实现两个表h1和h2的简单自然连接并生成单链表h.

第一行(HList &h)什么时候加&迷迷糊糊

2. 代码段2简介:采用顺序表存放有序表的二路归并算法

2.1 代码2

 void UnionList(SqList *LA,SqList *LB,SqList *&LC)                                                                                                //1
 {                                                                                                                                                                             //2
     int i = 0,j = 0,k = 0;                                    //i,j分别为LA,LB的下标,k为LC中元素的个数                                    //3        
     LC=(SqList *) malloc (sizeof(SqList));       //建立有序顺序表LC                                                                           //4
     while(i<LA->length&&j<LB->length)                                                                                                                    //5
     {                                                                                                                                                                          //6                                                                                                                                                               
         if(LA->data[i]<LB->data[i])                                                                                                                               //7
         {                                                                                                                                                                      //8
             LC->date[k]=LA->data[i]   ;                                                                                                                          //9
             i++,k++;                                                                                                                                                        //10
         }                                                                                                                                                                       //11
         else                                                                                                                                                                  //12
         {
              LC->date[k]=LA->data[j] ;                                                                                                                            //13
             j++,k++;                                                                                                                                                         //14
         }                                                                                                                                                                        //15
     }                                                                                                                                                                            //16
     while(i<LA->length)                                                                                                                                               //17              
     {                                                                                                                                                                            //18
         LC->date[k]=LA->data[i]   ;                                                                                                                                //19
         i++,k++;                                                                                                                                                             //20
     }                                                                                                                                                                             //21
  while(i<LB->length)                                                                                                                                                   //22            
     {                                                                                                                                                                             //23
         LC->date[k]=LA->data[j]   ;                                                                                                                                 //24
         j++,k++;                                                                                                                                                              //25
     }                                                                                                                                                                              //26
         LC->length=k;                                                                                                                                                        //27
 }                                                                                                                                                                                 //28
 (课本P67-68)

2.2 自己不懂得地方

    第5、15、22行。问题:语法不懂,这几个while循环的最坏执行次数不同,为什么时间复杂度却一样
展开阅读全文
加载中

作者的其它热门文章

打赏
0
0 收藏
分享
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部