数据结构第二章线性表总结

/*2.1线性表的定义和基本操作
InitList(&L);初始化表。
DestroyList(&L);销毁操作
LisInsert(&L,i,e);插入操作
LocateElem(L,e);按值查找
GetElem(L,i);按位查找

*/

//2.2顺序表
// 
//2.21
//1
#define MaxSize 10
typedef struct {
	ElemType data[MaxSize];
	int length;
}SqList;//静态分配方式
void InitList(SqList &L) {
	for (int i = 0; i < MaxSize; i++) {
		L.data[i] = 0;
	}
	L.length = 0;
}//初始化一个顺序表

//2
#define InitSize 10
typedef struct {
	ElemType *data;
	int MaxSize;
	int length;
}SqList;//动态分配方式
void InitList(SeqList &L) {
	L.data = (int *) malloc (InitSize * sizeof(int));
	L.length = 0;
	L.MaxSize = InitSize;
}//初始化一个顺序表

//2.22
//顺序表的插入(静态分配）
bool ListInsert(SqList &L, int i, int e) {
	if (i<1 || i>L.length + 1) {
		return false;
	}
	if (L.length >= MaxSize) {
		return false;
	}
	for (int j = L.length; j >= i, j--) {
		L.data[j] = L.data[j - 1];
	}
	L.data[i - 1] = e;
	L.length++;
	return ture;
}

//顺序表的删除(静态分配）
bool ListDelete(SqList& L, int i, int &e) {
	if (i<1 || i>L.length) {
		return false;
	}
	e = L.data[i - 1];
	for (int j = i; j < L.length, j++) {
		L.data[j-1] = L.data[j];
	}
	L.length--;
	return ture;
}

//2.23
//顺序表的查找
//1.按位查找
ElemType GetElem(Sqlist L, int i) {
	return L.data[i - 1];
}//静态分配

ElemType GetElem(Sqlist L, int i) {
	return L.data[i - 1];
}//动态分配

//2.按值查找
int LocateElem(SeqList L, ElemType e) {
	for (int i = 0; i < L.length; i++) {
		if (L.data[i] == e) {
			return i + 1;//数组下标为i的元素值等于e，返回其位序
		}
	}
	return 0；
}//动态分配

//在C语言中，结构体的比较不能直接用“==”，需要分别比较如if(a.num==b.num && a.people==b.people)；

//2.31
//单链表的定义
typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode,*LinkList;

//1.不带头结点
bool InitList(LinkList& L) {
	L = NULL;
	return true;
}
bool Empty(LinkList L) {
	if (L == NULL) 
		return true;
	else             //或者 return(L==NULL);
		return false;
}
void test() {
	LinkList L;
	InitList(L);
}

//2.带头结点，结构体定义相同
bool InitList(LinkList& L) {
	L = (LNode*) malloc (sizeof(LNode));
	if (L = NULL)
		return false;
	L->next = NULL;
	return ture;
}
bool Empty(LinkList L) {
	if (L->next == NULL)
		return true;
	else             
		return false;
}

//2.32
//按位序插入
//1.带头结点
typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;
bool ListInsert(LinkLIst& L, int i, ElemType e) {
	if (i < 1)
		return false;
	LNode* p;
	int j = 0;
	p = L;//L指向头结点，头结点是第0个结点（不存数据）；
	while (p != NULL && j <= i - 1) {//循环找到第i-1个结点
		p = p->next;
		j++;
	}
	if (p == NULL)
		return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//2.不带头结点
bool ListInsert(LinkList& L, int i, ElemType e) {
	if (i < 1)
		return false;
	if (i == 1) {//插入第一个结点的操作与其他结点操作不同
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		L = s;
		return true;
	}
	LNode* p;
	int j = 1;
	p = L;
	while (p != NULL && j < i - 1) {
		p = p->next;
		j++:
	}
	if (p == NULL)
		return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//指定结点的后插操作
bool ListInsert(LinkLIst& L, int i, ElemType e) {
	if (i < 1)
		return false;
	LNode* p;
	int j = 0;
	p = L;//L指向头结点，头结点是第0个结点（不存数据）；
	while (p != NULL && j <= i - 1) {//循环找到第i-1个结点
		p = p->next;
		j++;
	}
	return InsertNextNode(p, e);
}
bool InserNextNode(LNode* p, ElemType e) {//封装
	if (p == NULL)
		return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL)
		return false;//内存分配失败
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//指定结点的后插操作
bool InserPriorNode(LNode* p, ElemType e) {//封装
	if (p == NULL)
		return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL)
		return false;//内存分配失败
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;
	return true;
}

//按位序删除（带头结点）
typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;
bool ListDelete(LinkLIst& L, int i, ElemType &e) {
	if (i < 1)
		return false;
	LNode* p;
	int j = 0;
	p = L;//L指向头结点，头结点是第0个结点（不存数据）；
	while (p != NULL && j <= i - 1) {//循环找到第i-1个结点
		p = p->next;
		j++;
	}
	if (p == NULL)
		return false;
	if (p->next == NULL)
		return false;
	LNode* q = p->next;
	e = q->data;
	p->next = q->next;
	free(q); 
	return true;
}

//删除指定结点p，需要修改其前驱结点的next指针。方法一：传入头指针，循环寻找p的前驱结点。方法二：类似于结点前插的实现；
//方法二
bool DeleteNode(LNode* p) {//p不能是最后一个结点
	if (p = NULL)
		return false;
	LNode* q = p -> next;
	p->data = p->next->data;
	p->next = q->next;
	free(q);
	return true;
}
//2.33
//按位查找，返回第i个元素（带头结点）
LNode* GetElem(LinkList L, int i) {
	if (i < 1)
		return NULL;
	LNode* p;
	int j = 0;
	p = L;
	while (p != NULL && j < 1) {
		p = p->next;
		j++;
	}
	return p;
}

//按值查找,找到数据域==e的结点
LNode* LocationElem(LinkList L, ElemType e) {
	Lnode* p = L->next;
	while (p != NULL && p->data != 0) {
		p = p->next;
	}
	return p;
}

//求表长
int length(Linklist L) {
	int len = 0;
	Lnode* p = L;
	while (p->next != NULL) {
		p = p->next;
		len++;
	}
	return len;
}

//2.34
//单链表的建立
//1.尾插法
LinkList List_TailInsert(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));
	LNode* s, * r = L;
	scanf("%d", &s);
	while (x != 9999) {
		s = ((LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;
		r = s;
		scanf("%d", &x);
	}
	r->next = NULL;//尾结点置为空
	return L;
}

//2.头插法
LinkList List_HeadInsert(LinkList& L) {
	LNode* s;
	int x;
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;//初始为空链表
	scanf("%d", &s);
	while (x != 9999) {
		s = ((LNode*)malloc(sizeof(LNode));
		s->data = x;
		s->next = L->next;
		L->next = s;
		scanf("%d", &x);
	}
	return L;
}

//2.35
//双链表
typedef struct DNode {
	ElemType data;
	struct DNode* prior, * next;
}DNode,*DLinkList;
//初始化双链表
bool InitList(DLinklist& L) {
	L = (DNode*)malloc(sizeof(DNode));
	if (L == NULL)
		return false;
	L->prior = NULL;
	L->next = NULL;
	return true;
}
bool Empty(Dlinklist L) {//判空
	if (L->next == NULL)
		return true;
	else
		return false;

}
bool InserNextDNode(DNode* p, Dnode* s) {//插入
	if (p == NULL || S == NULL)
		return false;
	s->next = p->next;
	if (p->next != NULL)
		p->next->prior = s;
	s->prior = p;
	s->next = s;
	return true;
}
bool DeleteNextDNode(DNode* p) {//删除p结点后的后继结点
	if (p == NULL)
		return false；
		DNode * q = p->next;
	if (q == NULL)
		return false;
	p->next = q->next;
	if (q->next != NULL)
		q->next->prior = p;
	free(p);
	return true;
}
void DestoryList(Dlinklist& L) {//销毁
	while (L->next != NULL) {
		DeleteNextDNode(L);
		free(L);//销毁表时才能删除头结点
		L = NULL;
	}
}

//后向遍历
while (p != NULL) {
	.........
		p = p->next;
}
//向前遍历
while (p != NULL) {
	.........
		p = p->prior;
}
//向前遍历（跳过头结点）
while (p->prior != NULL) {
	.........
		p = p->prior;
}

//2.36
//循环链表
//1.循环单链表
typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;
bool InitList(LinkList& L) {//初始化
	L = (LNode*)malloc(sizeof(LNode));
	if (L == NULL)
		return false;
	L->next = L;//头结点next指向头结点
	return true;
}
bool Empyt(LinkList L) {//判空
	if (L - next == L)
		return true;
	else
		return false;
}
bool isTail(LinkList L, LNode* p) {//判断结点p是否为循环单链表的表尾结点
	if (p->next == L)
		return true;
	else
		return false;
}

//2.循环双链表
typedef struct DNode {
	ElemType data;
	struct DNode* prior, * next;
}DNode, * DLinkList;
//初始化双链表
bool InitList(DLinklist& L) {
	L = (DNode*)malloc(sizeof(DNode));
	if (L == NULL)
		return false;
	L->prior = L;
	L->next = L;
	return true;
}
bool Empty(Dlinklist L) {//判空
	if (L->next == L)
		return true;
	else
		return false;

}
bool isTail(DLinklist L, DNode* p) {
	if (p->next == L)
		return true;
	else
		return false;
}

//2.37
//静态链表
#define Maxsize 10
sturct Node{
	ElemType data;
    int next;
}
void testSLinkList() {
	sturct Node a[MaxSize];
	...................
}

#define Maxsize 10
sturct Node{
	ElemType data;
	int next;
}SlinkList[MaxSize];
//等价于下面
#define Maxsize 10
sturct Node{
	ElemType data;
	int next;
}；
typedef struct Node SlinkList[MaxSize];

//同样的
void testSLinkList() {
	SLinkList a;
	..........
}

//等价于下面
void testSLinkList() {
	struct Node a[MaxSize];
	..........
}