数据结构(二) 线性表-1

本节主要讲解的是线性表的顺序存储结构

1. 定义

线性表：零个或者多个数据元素的有限序列

  1. 它是一个序列，元素之间是有顺序的

    a1,a2,ai-1,ai,ai+1...an

i=1,有且仅有一个直接后继元素
i=[2,n]有且仅有一个直接前驱元素
    
当n=0,为空表

  2. 有限性，事实上，计算机处理的元素都是有限的，无限数列只存在数学概念中

举例：一个班的学生表就是线性表，因为每个学生有且仅有一个前驱和后继

公司部门的组织结构就不熟线性表：部门经理下有若干项目经理，项目经理下有若干组成员

2. 线性表的抽象数据类型

ADT List{

数据对象：D={ai|ai=ElemSet,i=1,2,..,n,n≥0}

数据关系：R1={<ai-1,ai>|ai-1,ai∈D,i=2,...,n}

基本操作：

	IniList(*L)操作结果：构造一个新的线性表L。

	DestroyList(*L)操作结果：销毁线性表

	ClearList(*L)操作结果：将L重置为空表

	ListEmpty(L)操作结果：若L为空表，则返回true，否则返回list

	ListLength(L)操作结果：返回L中数据元素个数

	GetElem(L,i,*e)初始条件：线性表已存在，1≤i≤ListLength(L) 将第i个数据元素的值返回给e

	LocateElem(L,e,compare())操作结果：返回L中第一个与e满足关系compare()的数据元素的位序。
    						若这样的数据元素不存在，则返回结果为0.

	PriorElem(L,cur_e,*pre_e)若cur-e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
    						否则操作失败，pre_e无定义

	NextElem(L,cur_e,*ext_e)若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
    						否则操作失败，next_e无定义

	ListInsert(*L,i,e)初始条件：线性表已存在，1≤i≤ListLength(L)+1
                           操作结果：在L中第i个位置之前插入新的数据元素e,L的长度加1

	ListDelete(*L,i,*e)初始条件： 线性表存在且非空，1≤i≤ListLength(L)
                             操作结果：删除L的第I个数据元素，并用e返回其值，L的长度减一

	ListTravarse(L,visit())操作结果：依次对L的每个数据元素调用函数visit().一旦visit()失败，
    					则操作失败。

}ADT List

对于不同的应用，线性表的操作是不同的，但是上述操作都是最基本的，对于实际问题中涉及的关于线性表的更复杂的操作，完全可以用这些基本操作组合来实现。

举例子：求线性表A和线性表B的并集， 即 A= AUB 。思路就是将存在B中但不存在A中的元素插入到A中。

假设 La，表示集合A, Lb表示集合B,实现代码如下

void union(List *La,List*Lb)
{
    int La_len,Lb_len,i;
    ElemType e;
    La_len=ListLength(La);
    Lb_len=ListLength(Lb);
    
    for(i=1;i<=Lb_len;i++)
    {
        GetElem(Lb,i,&e); //取得Lb第i个元素
        if(!LocateElem(La,e,equal)) //La不存在和e相同的数据元素
            ListInsert(La,++La_len,e)；//插入
    }
}

3. 线性表的顺序存储结构

3.1顺序存储结构定义

线性表的顺序存储是指在内存中用地址连续的一块存储空间顺序存放线性表的各元素。

3.2 顺序存储方式

在程序设计语言中，一维数组在内存中占用的存储空间就是一组连续的存储区域，因此，顺序存储的数据区域就是用一维数组来表示的。

i 0 1 2 3 ... MAXSIZE-1
Data a1 a2 a3 a4 ....

其中MAXSIZE是一个根据实际问题定义的足够大的整数。

3.2.1 线性表顺序存储结构代码

#define MAXSIZE 20 /*存储空间的初始分配量*/
Typedef int ElemType;
typedef struct{
	ElemType data[MAXSIZE]; //数组存储元素，最大值MAXSIZE
	int length;//线性表当前长度
}Sqlist;

顺序存储结构需要三个属性：

1）存储空间的起始位置：数组data

2）线性表最大存储容量：数组长度MAXSIZE

3）线性表当前长度：length

3.3数组长度和线性表长度区别

数组长度：存放线性表存储空间的长度

线性表长度：线性表中数据元素的个数

任意时刻,线性表长度<= 数组长度

3.4地址计算方法

假设线性表中元素为(a1，a2，…，ai-1，ai，ai+1，…，an)，ai的下标就是i-1

设第一个元素a1的内存地址为LOC(a1)，而每个元素在计算机内占t个存储单元，则第i个元素ai的首地址为：LOC(a1)+(i-1)×t(其中1≤i≤n)

LOC(ai)=LOC(a1)+(i-1)×t(其中1≤i≤n)

计算机对于每一个元素的存入和读取时间都是一样的，存取的时间复杂读为O(1)，对于这一特点的存储结构称之为随机存储结构。

4. 顺序存储结构的插入和删除

* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(SqList *L,int i,ElemType e)
{ 
	int k;
	if (L->length==MAXSIZE)  /* 顺序线性表已经满 */
		return ERROR;
	if (i<1 || i>L->length+1)/* 当i比第一位置小或者比最后一位置后一位置还要大时 */
		return ERROR;

	if (i<=L->length)        /* 若插入数据位置不在表尾 */
	{
		for(k=L->length-1;k>=i-1;k--)  /* 将要插入位置之后的数据元素向后移动一位 */
			L->data[k+1]=L->data[k];
	}
	L->data[i-1]=e;          /* 将新元素插入 */
	L->length++;

	return OK;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(SqList *L,int i,ElemType *e) 
{ 
    int k;
    if (L->length==0)               /* 线性表为空 */
		return ERROR;
    if (i<1 || i>L->length)         /* 删除位置不正确 */
        return ERROR;
    *e=L->data[i-1];
    if (i<L->length)                /* 如果删除不是最后位置 */
    {
        for(k=i;k<L->length;k++)/* 将删除位置后继元素前移 */
			L->data[k-1]=L->data[k];
    }
    L->length--;
    return OK;
}

5.线性表的顺序存储的优缺点

优点

  1. 无须为表中元素之间的逻辑关系增加额外的存储空间
  2. 可以快速进行存取，时间复杂度为O(1)

缺点

  1. 插入和删除操作，需要移动大量元素
  2. 当线性表长度变化较大时，难以确定存储空间容量
  3. 造成存储空间的碎片

5. 线性表的顺序存储代码

#include "stdio.h"    

#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;          /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;        /* ElemType类型根据实际情况而定，这里假设为int */


Status visit(ElemType c)
{
	printf("%d ", c);
	return OK;
}

typedef struct
{
	ElemType data[MAXSIZE];        /* 数组，存储数据元素 */
	int length;                                /* 线性表当前长度 */
}SqList;

/* 初始化顺序线性表 */
Status InitList(SqList *L)
{
	L->length = 0;
	return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(SqList L)
{
	if (L.length == 0)
		return TRUE;
	else
		return FALSE;
}

/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(SqList *L)
{
	L->length = 0;
	return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(SqList L)
{
	return L.length;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值,注意i是指位置，第1个位置的数组是从0开始 */
Status GetElem(SqList L, int i, ElemType *e)
{
	if (L.length == 0 || i<1 || i>L.length)
		return ERROR;
	*e = L.data[i - 1];

	return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(SqList L, ElemType e)
{
	int i;
	if (L.length == 0)
		return 0;
	for (i = 0; i < L.length; i++)
	{
		if (L.data[i] == e)
			break;
	}
	if (i >= L.length)
		return 0;

	return i + 1;
}


/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(SqList *L, int i, ElemType e)
{
	int k;
	if (L->length == MAXSIZE)  /* 顺序线性表已经满 */
		return ERROR;
	if (i<1 || i>L->length + 1)/* 当i比第一位置小或者比最后一位置后一位置还要大时 */
		return ERROR;

	if (i <= L->length)        /* 若插入数据位置不在表尾 */
	{
		for (k = L->length - 1; k >= i - 1; k--)  /* 将要插入位置之后的数据元素向后移动一位 */
			L->data[k + 1] = L->data[k];
	}
	L->data[i - 1] = e;          /* 将新元素插入 */
	L->length++;

	return OK;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(SqList *L, int i, ElemType *e)
{
	int k;
	if (L->length == 0)               /* 线性表为空 */
		return ERROR;
	if (i<1 || i>L->length)         /* 删除位置不正确 */
		return ERROR;
	*e = L->data[i - 1];
	if (i < L->length)                /* 如果删除不是最后位置 */
	{
		for (k = i; k < L->length; k++)/* 将删除位置后继元素前移 */
			L->data[k - 1] = L->data[k];
	}
	L->length--;
	return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(SqList L)
{
	int i;
	for (i = 0; i < L.length; i++)
		visit(L.data[i]);
	printf("
");
	return OK;
}

void unionL(SqList *La, SqList Lb)
{
	int La_len, Lb_len, i;
	ElemType e;
	La_len = ListLength(*La);
	Lb_len = ListLength(Lb);
	for (i = 1; i <= Lb_len; i++)
	{
		GetElem(Lb, i, &e);
		if (!LocateElem(*La, e))
			ListInsert(La, ++La_len, e);
	}
}

int main()
{

	SqList L;
	SqList Lb;

	ElemType e;
	Status i;
	int j, k;
	i = InitList(&L);
	printf("初始化L后：L.length=%d
", L.length);
	for (j = 1; j <= 5; j++)
		i = ListInsert(&L, 1, j);
	printf("在L的表头依次插入1～5后：L.data=");
	ListTraverse(L);

	printf("L.length=%d 
", L.length);
	i = ListEmpty(L);
	printf("L是否空：i=%d(1:是 0:否)
", i);

	i = ClearList(&L);
	printf("清空L后：L.length=%d
", L.length);
	i = ListEmpty(L);
	printf("L是否空：i=%d(1:是 0:否)
", i);

	for (j = 1; j <= 10; j++)
		ListInsert(&L, j, j);
	printf("在L的表尾依次插入1～10后：L.data=");
	ListTraverse(L);

	printf("L.length=%d 
", L.length);

	ListInsert(&L, 1, 0);
	printf("在L的表头插入0后：L.data=");
	ListTraverse(L);
	printf("L.length=%d 
", L.length);

	GetElem(L, 5, &e);
	printf("第5个元素的值为：%d
", e);
	for (j = 3; j <= 4; j++)
	{
		k = LocateElem(L, j);
		if (k)
			printf("第%d个元素的值为%d
", k, j);
		else
			printf("没有值为%d的元素
", j);
	}


	k = ListLength(L); /* k为表长 */
	for (j = k + 1; j >= k; j--)
	{
		i = ListDelete(&L, j, &e); /* 删除第j个数据 */
		if (i == ERROR)
			printf("删除第%d个数据失败
", j);
		else
			printf("删除第%d个的元素值为：%d
", j, e);
	}
	printf("依次输出L的元素：");
	ListTraverse(L);

	j = 5;
	ListDelete(&L, j, &e); /* 删除第5个数据 */
	printf("删除第%d个的元素值为：%d
", j, e);

	printf("依次输出L的元素：");
	ListTraverse(L);

	//构造一个有10个数的Lb
	i = InitList(&Lb);
	for (j = 6; j <= 15; j++)
		i = ListInsert(&Lb, 1, j);

	unionL(&L, Lb);

	printf("依次输出合并了Lb的L的元素：");
	ListTraverse(L);

	return 0;
}

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/chance0x1/p/13092359.html