数据结构_02_线性结构

一、线性表

1. 相关概念

1. 定义：线性表是具有相同特性数据元素的一个有限序列。序列中所含元素的个数叫做线性表的长度，用 $n$ 表示。当 $n=0$ 时，即表示该表为空表。
2. 表头、表尾、前驱、后继；
3. 存储结构：顺序存储结构（顺序表）、链式存储结构（链表）；
4. 链表的形式：单链表、双链表、循环单链表、循环双链表、静态链表（结构体数组）；
   
   注意：静态链表中的指针是指存储数组下标的整形变量；

---

2. 顺序表和链表的比较

• 顺序表：具有随机访问特性，要求占用连续的存储空间（静态分配）；
• 链表：不支持随机访问，存储空间利用率较顺序表稍低，支持动态分配；

1. 基于空间的比较
   1）存储分配的方式：
   顺序表的存储空间是一次性分配的，链表的存储空间是多次分配的；
   2）存储密度（ 存储密度 = 站点值域所占的存储量 / 站点结构所占的存储总量）
   顺序表的存储密度 = 1，链表的存储密度<1（结点中有指针域）；
2. 基于时间的比较
   1）存取方式：
   顺序表可以随机存取，也可以顺序存取；链表只能顺序存取；
   【所谓顺序存取，以读取为例，要读取某个元素必须遍历其之前的所有元素才能找到它并读取之】
   2）插入/删除时移动元素的个数：
   顺序表平均需要移动近一半元素；链表不需要移动元素，只需要修改指针。
   具有 $n$ 个元素的顺序表，插入一个元素所进行的平均移动个数为：
   $$E=p\sum _{i=1}^n(n-i)=\frac{n-1}{2}$$

---

3. 顺序表

1. 结构体定义：

// 链表--顺序存储结构
typedef int ElementType;
typedef int Position;

#define MAXSIZE 10000
typedef struct LNode *List;
struct LNode {
   
	ElementType Data[MAXSIZE];
	Position Last;	// 也可表示链表的长度	
};

2. 基本操作

/* 初始化 */
List MakeEmpty()
{
   
	List L;
	L = (List)malloc(sizeof(struct LNode));
	L->Last = -1;	// = 0，视情况而定
	return L;
}

/* 查找 */
#define ERROR -1
Position Find(List L, ElementType X)
{
   
	Position i = 0;
	while (i <= L->Last && L->Data[i] != X)
		i++;
	if (i > L->Last)  return ERROR; /* 如果没找到，返回错误信息 */
	else  return i;  /* 找到后返回的是存储位置 */
}

/* 插入 */
bool Insert(List L, ElementType X, Position P)
{
    /* 在L的指定位置P前插入一个新元素X */
	Position i;
	if (L->Last == MAXSIZE - 1) {
   
		/* 表空间已满，不能插入 */
		printf("表满");
		return false;
	}
	if (P<0 || P>L->Last + 1) {
    /* 检查插入位置的合法性 */
		printf("位置不合法");
		return false;
	}

	for (i = L->Last; i >= P; i--)
		L->Data[i + 1] = L->Data[i]; /* 将位置P及以后的元素顺序向后移动 */
	L->Data[P] = X;  /* 新元素插入 */
	L->Last++;       /* Last仍指向最后元素 */
	return true;
}

/* 删除 */
bool Delete(List L, Position P)
{
    /* 从L中删除指定位置P的元素 */
	Position i;
	if (P<0 || P>L->Last) {
    /* 检查空表及删除位置的合法性 */
		printf("位置%d不存在元素", P);
		return false;
	}

	for (i = P + 1; i <= L->Last; i++)
		L->Data[i - 1] = L->Data[i]; /* 将位置P+1及以后的元素顺序向前移动 */
	L->Last--; /* Last仍指向最后元素 */
	return true;
}

---

4. 单链表（含头结点）

1. 基本定义

// 链表 -- 链式存储
// 注意链表 是否包含头结点
typedef int ElementType;
typedef struct LNode *PtrToLNode;
struct LNode {
   
	ElementType Data;
	PtrToLNode Next;
//	PtrToLNode Prior;	// 双链表
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

2. 基本操作

/* 建立链表 */
List CreatList(ElementType a[], int n)
{
   
	List L = (List)malloc(sizeof(LNode));
	L->Next = NULL;
	Position P,tmp;
	P = L;
	for(int i=0; i<n; i++){
   
		tmp = (Position)malloc(sizeof(LNode));
		tmp->Data = a[i];
		// 尾插法：与数组中的原始序列顺序相同
		P->Next = tmp;
		P = P-Next;
		/* 头插法：与数组中的原始序列顺序相反
		tmp->Next = L->Next;
		L->Next = tmp;
		*/
	}
	P->Next = NULL;
}

/* 查找 */
#define ERROR NULL
Position Find(List L, ElementType X)
{
   
	Position p = L; /* p指向L的第1个结点 */
	while (p && p->Data != X)
		p = p->Next;

	/* 下列语句可以用 return p; 替换 */
	if (p)
		return p;
	else
		return ERROR;
}

/* 带头结点的插入 */
bool Insert(List L, ElementType X, Position P)
{
    /* 这里默认L有头结点 */
	Position tmp, pre;
	/* 查找P的前一个结点 */
	for (pre = L; pre&&pre->Next != P; pre