数据结构-线性表

线性表

线性表的定义

线性表是具有相同数据类型的 n (n>0)个数据元素的有限序列，其中 n 为表长，当n =0时线性表是一个空表。

线性表的特点

• 表中元素的个数有限
• 表中元素具有逻辑上的顺序性，表中元素有其先后次序
• 表中元素都是数据元素每个元索都是单个元素
• 每个元素占有相同大小的存储空间

线性表是一种逻辑结构，表示元素间一对一的关系，而顺序表和链表是指存储结构。

线性表的顺序表示

顺序表的定义

• 线性表的顺序存储又称顺序表。它是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。

• 一维数组的空间分配

  动态分配并不是链式存储，它同样属于顺序存储结构，物理结构没有变化，依然是随机存取方式，只是分配的空间大小可以在运行时动态决定。

  • 静态分配

    • 在静态分配时，由于数组的大小和空间事先已经固定，一旦空间占满，再加入新的数据就会产生溢出，进而导致程序崩溃。

  • 动态分配

    • 在动态分配时，存储数组的空间是在程序执行过程中通过动态存储分配语句分配的，一旦数据空间占满，就另外开辟一块更大的存储空间，用以替换原来的存储空间，从而达到扩充存储数组空间的目的，而不需要为线性表一次性地划分所有空间。

• 特点

  • 顺序表最主要的特点是随机访问，即通过首地址和元素序号可在时间 O(1)内找到指定的元素。
  • 顺序表的存储密度高，每个结点只存储数据元素。
  • 顺序表逻辑上相邻的元素物理上也相邻，所以插入和删除操作需要移动大量元素。

顺序表基本操作的实现

• 插入操作

  • 由于顺序表的中元素的物理位置是相邻的，所以当插入新元素的时候就需要对表中的元素进行整体移动。

  • 实现情况

    • 最好情况

      • 在表尾插入 (即i=n +1)，元素后移语句将不执行，时间复杂度为 O(1)

    • 最坏情况

      • 在表头插入(即i=1)，元素后移语句将执行 n 次，时间复杂度为 O(n)。

    • 平均情况

      • 表中任意合法位置插入，平均移动次数n/2，时间复杂度为 O(n)。

• 删除操作

  • 移动元素对想要删除的元素覆盖。

  • 实现情况

    • 最好情况

      • 删除表尾元素(即i=n，无须移动元素，时间复杂度为 O(1)

    • 最坏情况

      • 删除表头元素(即i= 1)，需移动除表头元素外的所有元素，时间复杂度为 O(n)。

    • 平均情况

      • 表中任意合法位置删除，平均移动次数（n-1）/2，时间复杂度为 O(n)。

• 按值查找

  • 即顺序查找：在顺序表 L中查找第一个元素值等于 e的元素，并返回其位序。

  • 实现情况

    • 最好情况

      • 查找的元素就在表头，仅需比较一次，时间复杂度为 O(1)。

    • 最坏情况

      • 查找的元素在表尾(或不存在)时，需要比较n 次，时间复杂度为 O(n)。

    • 平均情况

      • 平均比较次数（n+1）/2，时间复杂度为 O(n)。

线性表的链式表示

单链表的定义

线性表的链式存储又称单链表，它是指通过一组任意的存储单元来存储线性表中的数据元素。为了建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息外，还需要存放一个指向其后继的指针。

• 结构

  • 图2.3 单链表结点结构
    

  • 单链表结点类型描述

    typedef struct LNode{   //定义单链表结点类型
    	ElemType data;		//数据域
    	struct LNode *next; //指针域
    }LNode,*LinkList;
    

• 实现方式

  • 带头节点

    • 头结点和头指针的区分:不管带不带头结点，头指针都始终指向链表的第一个结点，而头结点是带头结点的链表中的第一个结点，结点内通常不存储信息。
    • 引入头结点后，可以带来两个优点:
      1.由于第一个数据结点的位置被存放在头结点的指针域中，因此在链表的第一个位置上的操作和在表的其他位置上的操作一致，无须进行特殊处理。 2.无论链表是否为空，其头指针都是指向头结点的非空指针(空表中头结点的指针域为空),因此空表和非空表的处理也就得到了统一。
    • 空表判断 L->next == NULL

  • 不带头结点

    • 空表判断 L == NULL

• 优缺点

  • 优点：不需要使用地址连续的存储单元，不要求逻辑上相邻的元素在物理位置上也相邻，它通过“链”建立起元素之间的逻辑关系，此插入和删除操作不需要移动元素。
  • 缺点：单链表附加指针域，也存在浪费存储空间的缺点。由于单链表的元素离散地分布在存储空间中，所以单链表是非随机存取的存储结构，即不能直接找到表中某个特定的结点。查找某个特定的结点时，需要从表头开始遍历，依次查找。

单链表上基本操作的实现

• 头插法

  • 图2.5 头插法建立单链表
    

  • 采用头插法建立单链表时，读入数据的顺序与生成的链表中的元素的顺序是相反的。每个结点插入的时间为 O(1)，设单链表长为n，则总时间复杂度为 O(n)。

    LinkList List_HeadInsert(LinkList &L){
    	LNode *s; int x;
    	L=(LinkList)malloc(sizeof(LNode)); //创建头结点
    	L->next=NULL;//初始为空链表
    	scanf("d",&x);//输入结点的值
    	while(x!=9999){//输入9999表示结束
    		s=(LNode*)malloc(sizeof(INode));//创建新结点
    		s->data=x;
    		s->next=L->next;
    		L->next=s;//将新结点插入表中，L为头指针
    		scanf("d",&x);
    	}
    	return L;
    }
    

• 尾插法

  • 图2.6 尾插法建立单链表
    

  • 将新结点插入到当前链表的表尾，为此必须增加一个尾指针 r，使其始终指向当前链表的尾结点。每个结点插入的时间为 O(1)，设单链表长为n，则总时间复杂度为 O(n)。

    LinkList List_TailInsert(LinkList &L){//正向建立单链表
    	int x;//设元素类型为整型
    	L=(LinkList)malloc(sizeof(LNode));
    	LNode*s,*r=L;//r为表尾指针
    	scanf("d",&x);//输入结点的值
    	while(x!=9999){//输入9999表示结束
    		s=(LNode *)malloc(sizeof(LNode));
    		s->data=x;
    		r->next=s;
    		r=s;//r指向新的表尾结点
    		scanf("d",&x);
    	}
    	r->next=NULL;//尾结点指针置空
    	return L;
    }
    

• 按序号查找结点

  • 在单链表中从第一个结点出发，顺指针 next 域逐个往下搜索，直到找到第 个结点为止，否则返回最后一个结点指针域NULL。时间复杂度为 O(n)。

    LNode *GetElem(LinkList L,int i){
    	if(i<1){
    		return NULL;
    	}
    	int j=1;
    	LNode *p = L->next;
    	while(p!=NULL&&j<i){
    		p=p->next;
    		j++;
    	}
    	return p;
    }
    

• 按值查找结点

  • 时间复杂度为 O(n)。

    LNode *LocateElem(LinkList L,int e){
    	LNode *p = L->next;
    	while(p!=NULL&&p->data!=e){
    		p=p->next;
    	}
    	return p;
    }
    

• 插入结点

  • 图2.7 单链表的插入操作
    

  • 实现

    p=GetElem(L,i-1);
    s->next=p->next;
    p->next=s;
    

• 删除结点

  • 图2.8 单链表的结点删除
    

  • 实现

    p=GetElem(L,i-1);
    q=p->next;
    p->next=q->next;
    free(q);
    

• 求表长

  • 求表长操作就是计算单链表中数据结点(不含头结点)的个数，需要从第一个结点开始顺序依次访问表中的每个结点，为此需要设置一个计数器变量，每访问一个结点，计数器加 1，直到访问到空结点为止。算法的时间复杂度为 O(n)。

双链表

• 插入

  • 图2.10 双链表插入结点
    

  • 实现

    s->next=p->next;
    p->next->prior=s;
    s->prior=p;
    p->next=s;
    

• 删除

  • 图2.11 双链表删除结点
    

  • 实现

    p->next=q->next;
    q->next->prior=p;
    free(q);
    

循环链表

• 循环单链表

  • 图2.12 循环单链表
    

  • 在循环单链表中，表尾结点*r的next 域指向L，故表中没有指针域为 NULL的结点，因此循环单链表的判空条件不是头结点的指针是否为空，而是它是否等于头指针。

• 循环双链表

  • 图2.13 循环双链表
    

  • 在循环双链表L中，某结点p 为尾结点时，p->next==L;当循环双链表为空表时，其头结点的 prior 域和 next 域都等于L。

静态链表

• 静态链表借助数组来描述线性表的链式存储结构，结点也有数据域 data 和指针域next与前面所讲的链表中的指针不同的是，这里的指针是结点的相对地址(数组下标)，又称游标和顺序表一样，静态链表也要预先分配一块连续的内存空间。

顺序表和链表的比较

• 存取方式

  • 顺序表可以顺序存取，也可以随机存取，链表只能从表头顺序存取元素。例如在第i个位置上执行存或取的操作，顺序表仅需一次访问，而链表则需从表头开始依次访问i次。

• 逻辑结构与物理结构

  • 采用顺序存储时，逻辑上相邻的元素，对应的物理存储位置也相邻。而采用链式存储时，逻辑上相邻的元素，物理存储位置不一定相邻，对应的逻辑关系是通过指针链接来表示的。

• 查找、插入和删除

  • 对于按值查找，顺序表无序时，两者的时间复杂度均为 O(n);顺序表有序时，可采用折半查此时的时间复杂度为 O(log2n)。对于按序号查找，顺序表支持随机访问，时间复杂度仅为 O(1)，而链表的平均时间复杂度为0(n)。顺序表的插入、删除操作，平均需要移动半个表长的元素。链表的插入、删除操作，只需修改相关结点的指针域即可。由于链表的每个结点都带有指针域，故而存储密度不够大。

• 空间分配

  • 链式存储的结点空间只在需要时申请分配，只要内存有空间就可以分配，操作灵活、高效。

• 存储结构选取的依据

  • 基于存储的考虑
  • 基于运算的考虑
  • 基于换背景的考虑