数据结构第二讲笔记之线性表（1）

#数据结构 Record Two#

先是一些概念性的东西：

线性表：由同类型数据元素构成有序序列的线性结构

1.表中元素个数称为线性表的长度；

2.线性表没有元素时，称为空表；

3.表起始位置称表头，表结束位置称表尾

首先是线性表的顺序存储实现和链式存储实现（只有函数部分的实现）

顺序存储：

/*线性表的顺序存储实现*/
typedef int Position;
typedef struct LNode *List;
struct LNode{
	ElementType Data[MAXSIZE];
	Position Last;
};

/*初始化*/
List MakeEmpty(){
	List L;
	L = (List)malloc(sizeof(struct LNode));
	L->Last = -1;
	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 , Position i , ElementType X){
	Position P;
	
	if(L->Last==MAXSIZE-1){
		printf("表满");
		return false; 
	}
	
	if(i<0 || i>L->Last+1){
		printf("位置不合法"); 
		return false;
	}
	
	for(P = L->Last ; P >= i ; P--){
		L->Data[P+1] = L->Data[P];
	}
	L->Data[P] = X;
	L->Last++;
	return true;
}

/*删除操作*/
bool Delete(List L , Position i){
	Position P
	if(i<0 || i>L->Last){
		printf("位置%d不存在元素",i);
		return false;
	}
	
	for(P = i+1 ; P <= L->Last ; P++){
		L->Data[P-1] = L->Data[P];
	}
	L->Last--;
	return true;
}

链式存储：

/*线性表的链式存储实现*/
typedef struct LNode *ProToLNode
struct LNode{
	ElementType Data;
	ProToLNode Next;
};
ProToLNode Position;
ProToLNode List;

/*查找操作*/
#define ERROR NULL
Position Find(List L , ElementType X){
	Position P = L;//令P等于表头指针
	while(P || P->Data!=X){
		P = P->Next;
	} 
	if(P){
		return P;
	}
	else{
		return ERROR;
	}
}

/*插入操作*/
bool Insert(List L , ElementType X , Position P){
	Position tmp , Pre;
	for(Pre = L , Pre&&Pre->Next!=P , Pre = Pre->Next);
	if(Pre==NULL){
		printf("插入位置参数错误\n")；
		return false; 
	}
	else{
		tmp = (Position)malloc(sizeof(struct LNode));
		tmp->Data = X;
		tmp->Next = P;
		Pre->Next = tmp;
		return true;
	}
}

/*删除操作*/
bool Delete(List L , Position P){
	Position Pre , tmp;
	for(Pre = L , Pre&&Pre->Next!=P , Pre = Pre->Next);
	if(Pre==NULL || P==NULL){
		printf("删除位置参数错误");
		return false;
	}
	else{
		Pre->Next = P->Next;
		free(P);
		return true;
	}
}

下面是一道合并两个有序链表序列的问题：

02-线性结构1 两个有序链表序列的合并（15 分）

本题要求实现一个函数，将两个链表表示的递增整数序列合并为一个非递减的整数序列。

函数接口定义：

List Merge( List L1, List L2 );

其中List结构定义如下：

typedef struct Node *PtrToNode;
struct Node {
    ElementType Data; /* 存储结点数据 */
    PtrToNode   Next; /* 指向下一个结点的指针 */
};
typedef PtrToNode List; /* 定义单链表类型 */

L1和L2是给定的带头结点的单链表，其结点存储的数据是递增有序的；函数Merge要将L1和L2合并为一个非递减的整数序列。应直接使用原序列中的结点，返回归并后的带头结点的链表头指针。

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct Node *PtrToNode;
struct Node {
    ElementType Data;
    PtrToNode   Next;
};
typedef PtrToNode List;

List Read(); /* 细节在此不表 */
void Print( List L ); /* 细节在此不表；空链表将输出NULL */

List Merge( List L1, List L2 );

int main()
{
    List L1, L2, L;
    L1 = Read();
    L2 = Read();
    L = Merge(L1, L2);
    Print(L);
    Print(L1);
    Print(L2);
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

3

1 3 5

5

2 4 6 8 10

输出样例：

1 2 3 4 5 6 8 10

NULL

NULL

下面代码：

List Merge(List L1 , List L2){
	List Pa , Pb , Pc , L;
	L = (List)malloc(sizeof(struct Node));
	Pc = L;
	Pa = L1->Next;
	Pb = L2->Next;
	while(Pa&&Pb){
		if(Pa->Data < Pb->Data){
			Pc->Next = Pa;
			Pa = Pa->Next;
		}
		else{
			Pc->Next = Pb;
			Pb = Pb->Next;
		}
		Pc = Pc->Next;
	}
	Pc->Next = NULL;
	if(Pa) Pc->Next = Pa;
	if(Pb) Pc->Next = Pb;
	L1->Next = NULL;
	L2->Next = NULL;
	return L;
}