C语言数据结构--线性表&链表

最新推荐文章于 2022-10-18 16:44:19 发布
最新推荐文章于 2022-10-18 16:44:19 发布
阅读量194 收藏 1
点赞数
文章标签： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZL1599292797/article/details/103350653
版权 
#ifndef XXB_H
#define XXB_H

#include"Head.h"

#define LIST_INT_SIZE	10000//表长
#define LISTINCREMENT	1000//表增量


//数据结构

//线性表顺序表示
typedef struct {
	ElemType_Int* elem;	//存储空间基址
	int length;			//当前长度
	int listsize;		//最大长度	
}SqList;

//链式表示

//不带头结点的单链表
typedef struct LNode {
	ElemType_Int data;	//数据域
	struct LNode* next;	//后继结点
}LNode, * LinkList;

//带头结点的单链表
typedef struct HLNode {
	ElemType_Int data;
	struct HLNode* next;
}HLNode, * HLink;
typedef struct {
	HLink head, tail;//指向头结点和最后一个结点
	int length;//链表中元素个数
}HLinkList;

//不带头结点的双向循环链表
typedef struct DuNode {
	ElemType_Int data;
	struct DuNode* prior, * next;//前驱和后继
}DuNode, * DuLinkList;


//多项式
typedef struct {
int coef;
int exp;
}PolyTerm;
typedef struct {
	PolyTerm* data;
	int length;
}SqPoly;
typedef struct PolyNode {
	PolyTerm data;
	struct PolyNode* next;
}PolyNode, * PolyLink;
typedef PolyLink LinkedPoly;


//函数声明

//初始化
Status InitSqList(SqList* L);
Status InitLinkList(LinkList* L);
Status InitHLinkList(HLinkList* L);
Status InitDuLinkList(DuLinkList* L);

//销毁
Status Destory_SqList(SqList* L);
Status Destory_LinkList(LinkList* L);
Status Destory_HLinkList(HLinkList* L);
Status Destory_DuLinkList(DuLinkList* L);

//探空
Status Empty_SqList(SqList L);
Status Empty_LinkList(LinkList L);
Status Empty_HLinkList(HLinkList L);
Status Empty_DuLinkList(DuLinkList L);

//求元素个数
int Length_SqList(SqList L);
int Length_LinkList(LinkList L);
int Length_HLinkList(HLinkList L);
int Length_DuLinkList(DuLinkList L);

//获取第i个元素的值
ElemType_Int GetElem_SqList(SqList L, int i);
ElemType_Int GetElem_LinkList(LinkList L, int i);
ElemType_Int GetElem_HLinkList(HLinkList L, int i);
ElemType_Int GetElem_DuLinkList(DuLinkList L, int i);

//求第一个与e满足关系compare()的数据的位序
Status compare(ElemType_Int a, ElemType_Int b, char* s);
int Locate_SqList(SqList L, ElemType_Int e,  char* s);
int Locate_LinkList(LinkList L, ElemType_Int e,  char* s);
int Locate_HLinkList(HLinkList L, ElemType_Int e,  char* s);
int Locate_DuLinkList(DuLinkList L, ElemType_Int e,  char* s);

//求前驱
Status Prior_LinkList(LinkList L, LNode cur_e, LinkList pre_e);
Status Prior_HLinkList(HLinkList L, HLNode cur_e, HLink pre_e);

//求后继
Status Next_LinkList(LinkList L, LNode cur_e, LinkList next_e);
Status Next_HLinkList(HLinkList L, HLNode cur_e, HLink next_e);

//在第i个位置之前插入e,若i大于线性表中元素个数，则在最后插入
Status Insert_SqList(SqList* L, ElemType_Int e, int i);
Status Insert_LinkList(LinkList* L, ElemType_Int e, int i);
Status Insert_HLinkList(HLinkList* L, ElemType_Int e, int i);
Status Insert_DuLinkList(DuLinkList* L, ElemType_Int e, int i);

//若第i个元素存在，删除它，并用e返回
Status Delete_SqList(SqList* L, ElemType_Int* e, int i);
Status Delete_LinkList(LinkList* L, ElemType_Int* e, int i);
Status Delete_HLinkList(HLinkList* L, ElemType_Int* e, int i);
Status Delete_DuLinkList(DuLinkList* L, ElemType_Int* e, int i);

//复制L
Status Copy_SqList(SqList L, SqList* Q);

//打印输出
//从0号位输出
void OutPutSqList(SqList L);
//0号位不输出
void OutPutSqList_1(SqList L);
void OutPutLinkList(LinkList L);
void OutPutHLinkList(HLinkList L);
void OutPutDuLinkList(DuLinkList L);

#endif // !XXB_H

#ifndef XXB_C
#define XXB_C

#include"List.h"

//初始化
Status InitSqList(SqList* L) {
	(*L).elem = (ElemType_Int*)malloc(LIST_INT_SIZE * sizeof(ElemType_Int));
	(*L).length = 0;
	(*L).listsize = LIST_INT_SIZE;
	return OK;
}
Status InitLinkList(LinkList* L) {
	*L = NULL;
	return OK;
}
Status InitHLinkList(HLinkList* L) {
	(*L).head = MALLOC(1, HLNode);
	(*L).tail = (*L).head;
	(*L).head->next = NULL;
	(*L).length = 0;
	return OK;
}
Status InitDuLinkList(DuLinkList* L) {
	*L = NULL;
	return OK;
}

//销毁
Status Destory_SqList(SqList* L) {
	free((*L).elem);
	(*L).elem = NULL;
	(*L).length = 0;
	return OK;
}
Status Destory_LinkList(LinkList* L) {
	LinkList p, q;
	p = *L;
	q = p;
	while (q) {
		q = p->next;
		free(p);
		p = q;
	}
	free(p);
	L = NULL;
	return OK;
}
Status Destory_HLinkList(HLinkList* L) {
	HLink p, q;
	p = (*L).head->next;
	q = p;
	while (q) {
		q = p->next;
		free(p);
		p = q;
	}
	free(p);
	free((*L).head);
	(*L).head = NULL;
	(*L).tail = (*L).head;
	(*L).length = 0;
	return OK;
}
Status Destory_DuLinkList(DuLinkList* L) {
	DuLinkList p, q;
	p = *L;
	q = p;
	while (q->next != *L) {
		q = p->next;
		free(p);
		p = q;
	}
	free(p);
	L = NULL;
	return OK;
}

//清空
Status Clear_SqList(SqList* L) {
	(*L).length = 0;
	return OK;
}
Status Clear_LinkList(LinkList* L) {
	L = NULL;
	return OK;
}
Status Clear_HLinkList(HLinkList* L) {
	(*L).head->next = NULL;
	(*L).tail = (*L).head;
	(*L).length = 0;
	return OK;
}
Status Clear_DuLinkList(DuLinkList* L) {
	L = NULL;
	return OK;
}

//探空
Status Empty_SqList(SqList L) {
	return !L.length ? OK : ERROR;
}
Status Empty_LinkList(LinkList L) {
	return !L ? OK : ERROR;
}
Status Empty_HLinkList(HLinkList L) {
	return L.head == L.tail ? OK : ERROR;
}
Status Empty_DuLinkList(DuLinkList L) {
	return !L ? OK : ERROR;
}

//求元素个数
int Length_SqList(SqList L) {
	return L.length;
}
int Length_LinkList(LinkList L) {
	LinkList p;
	int count;
	for (p = L, count = 0; p; p = p->next, count++);
	return count;
}
int Length_HLinkList(HLinkList L) {
	return L.length;
}
int Length_DuLinkList(DuLinkList L) {
	DuLinkList p;
	int count;
	for (p = L, count = 0; p->next != L; p = p->next, count++);
	return ++count;
}

//获取第i个元素的值
ElemType_Int GetElem_SqList(SqList L, int i) {
	if (i > L.length) {
		printf("there are only %d elements in the list\n", L.length);
		return 0;
	}
	return L.elem[i - 1];
}
ElemType_Int GetElem_LinkList(LinkList L, int i) {
	int count;
	LinkList p;
	for (p = L, count = 0; p && count < i - 1; p = p->next, count++);
	if (!p && count == i - 1) {
		printf("there are only %d elements in the list\n", count);
		return 0;
	}
	return p->data;
}
ElemType_Int GetElem_HLinkList(HLinkList L, int i) {
	int count;
	HLink p;
	for (p = L.head->next, count = 0; p && count < i - 1; p = p->next, count++);
	if (!p && count == i - 1) {
		printf("there are only %d elements in the list\n", count);
		return 0;
	}
	return p->data;
}
ElemType_Int GetElem_DuLinkList(DuLinkList L, int i) {
	int count;
	DuLinkList p = L;
	if (i == 1)
		return p->data;
	for (p = p->next, count = 2; p != L && count != i; p = p->next, count++);
	if (p == L) {
		printf("there are only %d elements in the list\n", count);
		return 0;
	}
	return p->data;
}

//求第一个与e满足关系compare()的数据的位序
Status compare(ElemType_Int a, ElemType_Int b, char* s) {
	if (!strcmp(s, "<")) {
		if (a < b)
			return OK;
	}
	else if (!strcmp(s, "<=")) {
		if (a <= b)
			return OK;
	}
	else if (!strcmp(s, "=")) {
		if (a == b)
			return OK;
	}
	else if (!strcmp(s, ">")) {
		if (a > b)
			return OK;
	}
	else if (!strcmp(s, ">=")) {
		if (a >= b)
			return OK;
	}
	return ERROR;
}
int Locate_SqList(SqList L, ElemType_Int e, char* s) {
	int pos = 1;
	while (!compare(L.elem[pos], e, s) && pos < L.length) 
		pos++;
	if (!compare(L.elem[pos], e, s) && pos == L.length)
		return 0;
	else
		return pos;
}
int Locate_LinkList(LinkList L, ElemType_Int e, char* s) {
	int pos = 1;
	LinkList p = L;
	while (p&&!compare(p->data, e, s))
		pos++;
	if (!p || (p && !compare(p->data, e, s)))
		return 0;
	else
		return pos;
}
int Locate_HLinkList(HLinkList L, ElemType_Int e, char* s) {
	int pos = 1;
	HLink p = L.head->next;
	while (p && !compare(p->data, e, s))
		pos++;
	if (!p || (p && !compare(p->data, e, s)))
		return 0;
	else
		return pos;
}
int Locate_DuLinkList(DuLinkList L, ElemType_Int e,  char* s) {
	DuLinkList p = L;
	if (compare(p->data, e, s))
		return 1;
	int pos = 2;
	p = p->next;
	while (p!= L && !compare(p->data, e, s)) {
		p = p->next;
		pos++;
	}
	if (p == L)
		return 0;
	else
		return pos;
}

//求前驱
Status Prior_LinkList(LinkList L,LNode cur_e,LinkList pre_e){
	LinkList p, q;
	p = L;
	if (p->data == cur_e.data)
		return ERROR;
	q = p->next;
	while (q) {
		if (q->data == cur_e.data)
			break;
		p = q;
		q = q->next;
	}
	if (!q)
		return ERROR;
	pre_e = p;
	return OK;
}
Status Prior_HLinkList(HLinkList L, HLNode cur_e, HLink pre_e) {
	HLink p, q;
	p = L.head->next;
	if (p->data == cur_e.data)
		return ERROR;
	q = p->next;
	while (q) {
		if (q->data == cur_e.data)
			break;
		p = q;
		q = q->next;
	}
	if (!q)
		return ERROR;
	pre_e = p;
	return OK;
}

//求后继
Status Next_LinkList(LinkList L, LNode cur_e, LinkList next_e) {
	LinkList p, q;
	p = L;
	q = p->next;
	while (q) {
		if (p->data == cur_e.data)
			break;
		p = q;
		q = q->next;
	}
	if (!q)
		return ERROR;
	next_e = p;
	return OK;
}
Status Next_HLinkList(HLinkList L, HLNode cur_e, HLink next_e) {
	HLink p, q;
	p = L.head->next;
	q = p->next;
	while (q) {
		if (p->data == cur_e.data)
			break;
		p = q;
		q = q->next;
	}
	if (!q)
		return ERROR;
	next_e = p;
	return OK;
}

//在第i个位置之前插入e,若i大于线性表中元素个数，则在最后插入
Status Insert_SqList(SqList* L, ElemType_Int e, int i) {
	if ((*L).length == (*L).listsize) {
		(*L).elem = REALLOC((*L).elem, ((*L).length + LISTINCREMENT),ElemType_Int);
		(*L).listsize += LISTINCREMENT;
	}
	if (i > (*L).length) {
		(*L).elem[++(*L).length - 1] = e;
		return OK;
	}
	int j;
	for (j = (*L).length - 1; j >= i - 1; j--)
		(*L).elem[j + 1] = (*L).elem[j];
	(*L).elem[i - 1] = e;
	(*L).length++;
	return OK;
}
Status Insert_LinkList(LinkList* L, ElemType_Int e, int i) {
	int count;
	LinkList p, q, t;
	t = MALLOC(1, LNode);
	t->data = e;
	t->next = NULL;
	if (!(*L))
		*L = t;
	else {
		for (p = *L, q = p, count = 0; p && count < i - 1; count++, q = p, p = p->next);
		if (p == *L) {
			t->next = *L;
			*L = t;
			return OK;
		}
		t->next = p;
		q->next = t;
	}
	return OK;
}
Status Insert_HLinkList(HLinkList* L, ElemType_Int e, int i) {
	HLink p, q, t;
	int count;
	t = MALLOC(1, HLNode);
	t->data = e;
	if ((*L).length < i) {//是否插在最后
		t->next = NULL;
		(*L).tail->next = t;
		(*L).tail = t;
		return OK;
	}
	for (p = (*L).head, q = p, count = 0; p && count < i - 1; count++, q = p, p = p->next);
	if (p == q) {
		t->next = p->next;
		p->next = t;
		return OK;
	}
	t->next = q;
	p->next = t;
	return OK;
}
Status Insert_DuLinkList(DuLinkList* L, ElemType_Int e, int i) {
	if (!*L) {
		(*L) = MALLOC(1, DuNode);
		(*L)->data = e;
		(*L)->prior = *L;
		(*L)->next = *L;
		return OK;
	}
	int count;
	DuLinkList p, t;
	for (p = *L, count = 1; count < i; p = p->next, count++);
	t = MALLOC(1, DuNode);
	t->data = e;
	t->next = p;
	t->prior = p->prior;
	t->prior->next = t;
	p->prior = t;
	return OK;
}

//若第i个元素存在，删除它，并用e返回
Status Delete_SqList(SqList* L, ElemType_Int* e, int i) {
	if ((*L).length < i)
		return ERROR;
	*e = (*L).elem[i - 1];
	for (; i < (*L).length - 1; i++)
		(*L).elem[i - 1] = (*L).elem[i];
	(*L).length--;
	return OK;
}
Status Delete_LinkList(LinkList* L, ElemType_Int* e, int i) {
	int count;
	LinkList p, q;
	for (p = *L, q = p, count = 0; p && count < i - 1; count++, q = p, p = p->next);
	if (!p)
		return ERROR;
	*e = p->data;
	if (p == *L)
		*L = (*L)->next;
	else
		q->next = p->next;
	free(p);
	return OK;
}
Status Delete_HLinkList(HLinkList* L, ElemType_Int* e, int i) {
	HLink p, q;
	int count;
	for (p = (*L).head->next, q = p, count = 0; p && count < i - 1; count++, q = p, p = p->next);
	if (!p)
		return ERROR;
	*e = p->data;
	(*L).length--;
	if (p == q)
		(*L).head->next = p->next;
	else
		q->next = p->next;
	free(p);
	return OK;
}
Status Delete_DuLinkList(DuLinkList* L, ElemType_Int* e, int i) {
	int count;
	DuLinkList p, q;
	for (p = *L, q = p, count = 0; p && count < i - 1; count++, q = p, p = p->next);
	if (!p)
		return ERROR;
	*e = p->data;
	if (p == *L) {
		(*L)->next->prior = NULL;
		*L = (*L)->next;
	}
	else {
		q->next = p->next;
		p->next->prior = q;
	}
	free(p);
	return OK;
}

//复制L
Status Copy_SqList(SqList L, SqList* Q) {
	(*Q).length = L.length;
	(*Q).listsize = L.listsize;
	for (int i = 0; i < L.length; i++)
		(*Q).elem[i] = L.elem[i];
	return OK;
}

//打印输出
//从0号位输出
void OutPutSqList(SqList L) {
	for (int i = 0; i < L.length; printf("%5d", L.elem[i++]));
	printf("\n");
}
//0号位不输出
void OutPutSqList_1(SqList L) {
	for (int i = 1; i <= L.length; printf("%5d", L.elem[i++]));
	printf("\n");
}
void OutPutLinkList(LinkList L) {
	LinkList p;
	for (p = L; p; printf("%3d", p->data), p = p->next);
	printf("\n");
}
void OutPutHLinkList(HLinkList L) {
	HLink p;
	for (p = L.head->next; p; printf("%3d", p->data), p = p->next);
	printf("\n");
}
void OutPutDuLinkList(DuLinkList L) {
	DuLinkList p;
	p = L;
	do {
		printf("%3d", p->data);
		p = p->next;
	} while (p != L);
	printf("\n");
}

#endif // !XXB_C

 

QiQaWgYu
关注
数据结构之线性表（顺序表、单链表、双链表）
C语言与CPP编程的博客
10-26 1965
1 线性表的基本概念 对于同一个线性表，其每一个数据元素的值虽然不同，但必须具有相同的数据类型； 数据元素之间具有一种线性的或“一对一”的逻辑关系； 第一个数据元素没有前驱，这个数据元素被称为开始节点； 最后一个数据元素没有后继，这个数据元素被称为终端节点； 除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继； 2 线性表抽象数据类型描述 基本操作如下： 线性表的置空操作clear()：将一个已经存在的线性表置为空表；
双向链表DuLinkList定义与操作
qq_32535377的博客
03-28 2740
/* 1、双向链表的优点：大部分与单链表差不多，主要的区别在于，向后寻查结点的复杂度为O(1) 2、双向链表的缺点：同单链表类似，同时比单链表占据更大的内存 */ #include #define OK 1 #define ERROR 0 typedef int Status;//表示返回的状态值  typedef int ElemType;
关于数据结构链表问题（C语言实现）—— 线性表顺序存储设计与实现
CSDNKKKKK的博客
04-18 244
这是我的第一篇博客（内容为废话） 现在马上面临毕业的我，发现整理总结问题真的非常重要，刚刚开始学习数据结构，并且非科班出身的我，感觉得到压力非常大，所以开始学习完后在这进行回忆，复习学习。在这里要感谢传智播客的讲师传智扫地僧的课程。刚开始，肯定会有很多不好的地方，慢慢改变积少成多。特别喜欢一句话叫，十年饮冰，难凉热血。 数据结构之线性表顺序存储 废话不多说，直接上代码吧： #ifndef __M...
数据结构（五）——双链表与循环链表
流逝
08-03 1438
数据结构（五) —— 双链表和循环链表
带头结点双链表（循环）基本操作实现解析
weixin_42224065的博客
10-18 877
双链表，双循环链表，带头双循环链表，不带头双循环链表，带头初始化方式，外部结点
C语言-数据结构-线性表
xufang461010923的专栏
05-07 1086
最近在学习自考课程中的《数据结构》，课程代码为02331，使用的教程是2012年版的（主编：苏仕华）。一开始学习时，有些困难，因为我没学习过C，教材中的算法虽然能理解，但不能完全吃透。 所以，又转去恶补C的基础知识，如：数组，指针，结构体，宏定义，typedef…等等。 现在回来了，再看这些算法容易多了，自己将“顺序表”的基本运算补充实现了，贴上来，给有相同经历的考生一点点帮助。 1. 线性表的基...
C语言数据结构--线性表
别下完这场雪
05-30 3758
严蔚敏老师的C语言数据结构一书中，使用的都是伪代码，实际运行总是会出现问题，这里将线性表的伪代码补全，还有完整的程序代码
数据结构---线性表之单链表（C语言）
03-28
单链表是数据结构中的一种基础类型，尤其在C语言编程中经常被使用。它是一种线性的、非连续的数据组织形式，每...通过C语言实现，我们可以直观地理解链表的工作原理，这对于进一步学习高级数据结构和算法具有重要意义。
数据结构---线性表之双链表（C语言）
03-29
双链表是数据结构中的一个重要概念，尤其在C语言编程中有着广泛的应用。本文将深入探讨双链表的基本原理，以及如何使用C语言实现双链表的创建、插入和删除操作。 双链表是一种线性数据结构，与单链表不同，它在每个...
数据结构C语言代码--线性表.7z
03-22
总结，线性表是数据结构的基础，理解和掌握其原理及C语言实现对于编程至关重要。无论是数组还是链表实现，都需要根据具体应用场景选择合适的数据结构，以达到高效的操作性能。在实际编程中，理解并熟练运用线性表的...
DuLinkList.cpp
02-03
严蔚敏数据结构DuLinkList
数据结构与算法 c语言 线性表-静态链表
最新发布
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
DuLinkList
10-26 1662
#include using namespace std; #define OK 1 #define ERROR -1 #define TRUE 1 #define FALSE 0 #define OVERFLOW -2 typedef char ElemType; typedef struct DuLNode { /***********************************
c++实现双链表的基本操作
weixin_45548868的博客
04-01 232
#include <iostream> using namespace std; #define MAXSIZE 20 #define TRUE 1 #define FALSE 0 typedef bool Status; /* Status是函数的类型,其值是函f数结果状态代码*/ typedef char ElemType; /* ElemType...
【数据结构】双向链表定义和基本操作
Z_sea的博客
12-18 5892
双向链表： 双向链表的定义： typedef struct DuLNode{ LElemType data; struct DuLNode *next; struct DuLNode *pre; DuLNode ( LElemType Data=0,struct DuLNode *Pre=NULL,struct DuLNode *Next=NULL){ ...
双向循环链表
热门推荐
xu_ya_fei的专栏
11-12 1万+
双向循环链表
双向链表的建立及基本操作
gets_s的博客
03-11 218
#include<windows.h> #include<iostream> #define N 5 using namespace std; typedef struct DuLnode { int data; struct DuLnode *prior; //前驱结点 struct DuLnode *next; //后继结点 }DuLnode, *DuLink...
Unity 【Content Size Fitter】- 聊天气泡自动适配Text文本框大小
当代野生程序猿
02-25 5763
通常在展示人物对话的时候文本的长度是不定的，因此会需要动态的调整对话内容文本框的背景图片的大小，这里以如下这种气泡框的对话为例： 实现该需求涉及到的内容包括Content Size Fitter组件的使用、2D Sprite工具包的使用。 Content Size Fitter组件用于Text文本框，如图所示，我们将Horzontal Fit设为Preferred Size，当我们调整Text文本框中的内容时，其大小会自动进行调整。 注意Rect Transform中Pivot轴心点的设置
C语言数据结构习题解析：线性表到图论
"该资源是耿国华版的数据结构习题答案，主要涵盖C语言描述的数据结构，包括线性表、栈、队列、字符串、广义表、树、图论、查找、排序等核心概念的算法实现。此外，还涉及了数据结构的基本理论，如数据结构的定义、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值