《数据结构与算法》课程笔记 第二章 2.1 线性表(2)

1. 线性表的应用

1 合并线性表

• 先分析性能，后再通过代码实现。
• List_Insert：顺序存储和链式存储结构的时间复杂度最坏情况下都是 O(N)。但是若在头结点插入，顺序结构：O(N)，链式结构：O(1)；若在尾结点插入， 顺序结构：O(1)，链式结构：O(N)。
• 合计：顺序结构：，链式结构：
• 虽然顺序存储结构编程简单，且其中有多步都是常数时间。但除了插入操作，其它操作时间都花在定位上，非常快，且顺序存储结构在插入操作时需要移动数据元素。所以最佳的选择是链式存储结构。

底层代码顺序存储结构的实现： 

Status List_Union(SqlListPtr La, SqlListPtr Lb)
{
	Status status = success;
	for(int i=1;i<=Lb->length;i++)
	{
		int j;
		for(j=1;j<=La->length;j++)
		{
			if(Lb->elem[i] == La->elem[j])
				break;
		}
		if (La->length < LIST_INIT_SIZE) //La有位置可以插入
		{
			if (j > La->length) //La中没有该元素
			{
				La->length++;
				int len = La->length;
				La->elem[len] = Lb->elem[i]; //在末尾插入（顺序存储结构在末尾插入方便）
			}
		}
		else
		{
			status = fail;
			break;
		}
	}
	return status;
}

使用基础操作：

Status List_Union(SqListPtr La, SqListPtr Lb)
{
	ElemType elem;          //存放从 Lb 中取出的元素
	Status status;          //状态代码
	int i,j;
	int len = List_Size(Lb);  //len 存放 Lb 的元素个数
	for(i=1;i<=len;i++)
	{
		List_Retrieve(Lb,i,&elem);  //取出 Lb 中第 i 个数据元素
		status = List_Locate(La,elem,&j);  //判断它是否在 La 中
		if (status!=success) //如果不在
		{
			status = List_Insert(La,1,elem); //插入到第一个位置（链式存储结构在第一个位置插入方便）
			if(status!=success)
				break;                       //插入失败则退出
		}
		else List_Add(La,j,1);          //La 的第 j 个数据加1
	}
	return status;
}

 2 合并有序表

Status List_Merge(SqListPtr La, SqListPtr Lb, SqListPtr Lc)
{
	ElemType elem1, elem2;
	status = List_Init(Lc);
	int i = 1, j = 1, k = 1;  //i,j,k分别用于指示 La,Lb,Lc中当前元素
	int n = List_Size(La);
	int m = List_Size(Lb);
	while(i<=n && j<=m)//两个表都还未处理完
	{
		List_Retrieve(La,i,&elem1);
		List_Retrieve(Lb,j,&elem2);
		if (elem1 < elem2)
		{
			status = List_Insert(Lc,k,elem1);
			i = i+1;
		}
		else
		{
			status = List_Insert(Lc,k,elem2);
			j = j+1;
		}
		k = k+1;
	}
	while(i <= n)//表La还未处理完
	{
		List_Retrieve(La,i,&elem1);
		status = List_Insert(Lc,k,elem1);
		i = i+1;
		k = k+1;
	}
	while(j <= m)//表Lb还未处理完
	{
		List_Retrieve(Lb,j,&elem2);
		status = List_Insert(Lc,k,elem2);
		j = j+1;
		k = k+1;
	}
	return status;
}

• 链式存储结构效率更高：不需要再重新分配空间给第三个链表，直接使用原来的内存空间；不需要进行数据元素的拷贝。 

底层代码链式结构的实现： 

void merge_linklist(SqListPtr La, SqListPtr Lb, SqListPtr Lc)
{//la和lb为参与归并的两个有序表，lc为结果有序表
	Ptr pa,pb,pc,tp;
	pa = (*La)->next;
	pb = (*Lb)->next;
	pc = *La;
	while(!pa && !pb)
	{
		if (pa->data < pb->data)
		{
			pc->next = pa;
			pc = pa;
			pa = pa->next;
		}
		else if (pa->data > pb->data)
		{
			pc->next = pb;
			pc = pb;
			pb = pb->next;
		}
		else   //值相等的情况
		{
			pc->next = pa;
			pc = pa;
			pa = pa->next;
			tp = pb;
			pb = pb->next;
			free(tp);
			tp = NULL;
		}
	}
	pc->next = (pa ? pa : pb);  //插入剩余段
	free(Lb);
	Lc = La;
}

2. 栈和队列

• 栈和队列是限定插入和删除只能在表的“端点”进行的线性表。 

• 栈和队列是特殊的线性表，是插入、删除操作受限的线性表。  

2.1 栈

•  栈是限定在表的同一端进行插入或删除操作的线性表。没有数据元素的栈称为空栈。
• 进行插入或删除操作的一端称为栈顶，另一端称为栈底。
• 插入数据元素的操作称为入栈，删除数据元素的操作称为出栈。
• 栈的运算特性：后进先出（Last In First Out--LIFO）或先进后出。

2.1.1 栈的基本操作及测试

2.1.2 顺序存储结构栈

类型定义：

typedef struct Stack
{
	int top; //就是线性表顺序存储结构的length（栈顶位置）
	StackEntry* elem; //动态分配空间大小为stack_size（一开始将总体空间都分配出来）
	int stack_size;  //能存储的总空间大小
}Stack,*StackPtr;

•  域 elem[0,...,stack_size-1] 用于存放数据元素
• 约定 top 用于存放栈顶元素的位置。top = -1 表示空栈；top = stack_size-1 表示栈满。 

 

•  溢出：顺序栈的数据元素空间大小是预先分配的。当空间全部占满后再入栈产生的溢出称为“上溢”；当栈为空时再出栈也将产生的溢出称为“下溢”。

顺序栈基本操作实现：入栈操作 

Status Stack_Push(StackPtr s, StackEntry item)
{
	Status outcome = success;
	if(s->top == MAXSTACK-1)
		outcome = overflow; //栈满则上溢
	else
	{
		s->top++;
		s->elem[s->top] = item; //数据元素放入top位置（top先加1，再放数据元素）
	}
	return outcome;
}

 顺序栈基本操作实现：出栈操作 

Status Stack_Pop(StackPtr s, StackEntry *item)
{
	Status outcome = success;
	if(s->top == -1)
		outcome = underflow; //栈空则下溢
	else
		*item = s->elem[s->top--]; //将top所指数据元素放入item,top再减1。
		/**item = s->elem[s->top];
		s->top--;*/
	return outcome;
}

 顺序栈基本操作实现：取栈顶元素操作  

Status Stack_Top(StackPtr s,StackEntry *item)
{
	Status outcome = success;
	if(Stack_Empty(s))
		outcome = underflow; //栈空则下溢
	else
		*item = s->elem[s->top]; //取出数据，top指针不变
	return outcome;
}

2.1.3 链式存储结构栈

• 单链表在链表头部进行插入和删除操作时比较简单，速度快。
• 栈顶：单链表头部 

 类型定义：

typedef struct Node  //结点类型定义
{
	StackEntry entry;
	struct Node* next;
}StackNode, *StackNodePtr;

typedef struct Stack //链栈类型定义
{
	StackNodePtr top;  //指向栈顶的指针
}Stack, *StackPtr;

• 空栈时 top == NULL 。

链栈基本操作实现：入栈操作  

Status Stack_Push(StackPtr s, StackEntry item)
{
	Status outcome = success;
	StackNodePtr np = MakeNode(item); //申请结点空间，并装填结点域
	/*StackNodePtr np = (StackNodePtr)malloc(sizeof(Node));
	np->entry = item;
	np->next = NULL;*/
	if(np == NULL)
		outcome = overflow; //无法分配存储空间，相当于栈满上溢
	else 
	{
		np->next = s->top; //所申请到的结点插入在表头（top指针指向链栈的第一个数据元素,最新插入的都放在表头）
		s->top = np; //top指向栈顶元素，现在栈顶元素变成 np 指向的元素
	}
	return outcome;
}

链栈基本操作实现：出栈操作   

Status Stack_Pop(StackPtr s, StackEntry *item)
{
	Status outcome = success;
	if(Stack_Empty(s))
		outcome = underflow; //栈空则下溢
	else
	{
		StackNodePtr np = s->top; //删除栈顶元素
		s->top = np->next;
		*item = np->entry;
		free(np);
	}
	return outcome;
}

链栈基本操作实现：取栈顶元素操作    

Status Stack_Top(StackPtr s, StackEntry *item)
{
	Status outcome = success;
	if(Stack_Empty(s))
		outcome = underflow; //栈空则下溢
	else 
		*item = s->top->entry;  //s->top是结点类型
	return outcome;
}

• 链栈：入栈、出栈、取栈顶的时间复杂度都是 O(1)。不受顺序栈必须预估空间大小的限制。

• 入栈：i、j、k。不可能的出栈顺序：k、i、j。
• 括号配对问题也使用栈来实现，后出现先配对。

 2.2 队列

• 队列是限定只能在表的一端进行插入，在表的另一端进行删除的线性表。
• 队尾（rear）：允许插入的一端
• 队头（front）：允许删除的一端
• 队列特点：先进先出（FIFO） 

2.2.1 队列的基本操作

• 链式结构：入队操作定位时间较长。顺序结构：出队操作需要大量移动数据。

2.2.2 顺序队列

顺序队列类型定义： 

typedef struct Queue
{
	int front,rear; //队头和队尾指针，指示队头和队尾数据元素的位置
	QueueEntry entry[MAXQUEUE]; //数据元素存储空间
}Queue, *QueuePtr;  //定义为新的数据类型

• 初始 front = rear = 0 或者 front = rear = -1 都是可以的。
• 如果 front = rear = 0，表示 front 指向第一个元素，rear 指向最后一个元素的后面；
• front = rear = -1，表示 front 指向第一个元素前面，rear 指向最后一个元素。
• 这里规定：front = rear = -1，即 front 指向第一个元素前面一个位置，rear 指向最后一个元素的位置。

        

• 解决“假溢出”现象：视为“循环顺序队列”。
• 实现方法：front = (front+1)%MAXQUEUE;    rear = (rear+1)%MAXQUEUE;
• 队满和队空的判断条件都是：s->front == s->rear; 如何解决判满和判空的问题？

循环顺序队列判断满还是空：

• 本质上解决：循环队列满的本质为队列长度和空间大小相同；空的本质为队列长度为0。所以可以通过一个计数器的值是0还是空间大小来判断是满还是空。
• 产生的原因：循环队列满的原因是入队操作产生的；空的原因是出队操作产生的。所以可以通过一个标记是入队还是出队来判断是满还是空。
• 不允许出现：让一种情况不出现，如让空间大小还有一个位置时就认为是满的。
• 优先选用第三种方案，不需要额外的变量。

      

2.2.3 链式队列

链式队列类型定义： 

typedef struct Node //链式队列的结点结构
{
	QueueEntry entry;  //队列数据元素类型
	struct Node* next; //指向后继结点的指针
}QueueNode, *QueueNodePtr;

typedef struct Queue //链式队列
{
	QueueNode *front; //队头指针
	QueueNode *rear;  //队尾指针
}Queue, *QueuePtr;

链式队列基本操作实现：初始化操作

void Queue_Init(QueuePtr q)
{
	QueueNode hNode;
	hNode = (QueueNode)malloc(sizeof(QueueNode));
	q->front = &hNode;
	q->rear = &hNode;
}

• 最后一个元素出队时，增加一个操作：Q->rear = Q->front;