数据结构-线性结构-线性表-单链表的初步实现

冰铃月

已于 2023-10-05 00:19:47 修改

阅读量79

点赞数 2

文章标签： c++ 算法数据结构

于 2023-10-04 03:38:52 首次发布

本文链接：https://blog.csdn.net/qq_72946470/article/details/133536767

版权

#include<iostream>
#include<cstdlib>
#include<cstdio>

#define OK 1
#define ERROR -1

typedef int ElemType;
typedef int Status;

typedef struct LNode {
	ElemType elem;
	struct LNode* next;
}LNode;

typedef struct LinkList {
	int length;
	struct LNode* head;
	struct LNode* end;
}LinkList;

Status InitLinkList(LinkList& L);//fun_1
Status CreateLinkList(LinkList& L);//fun_2
Status DestroyList(LinkList& L);//fun_3
Status ClearList(LinkList& L);//fun_4
Status ListEmpty(LinkList& L);//fun_5
Status ListLength(LinkList& L);//fun_6
Status GetElem(LinkList& L, int i, ElemType& e);//fun_7
Status LocateElem(LinkList& L, int e);//fun_8
Status PriorElem(LinkList& L, int cur_e, ElemType& pre_e);//fun_9
Status NextElem(LinkList& L, int cur_e, ElemType& next_e);//fun_10
Status ListInsert(LinkList& L, int i, ElemType e);//fun_11
Status ListDelete(LinkList& L, int i);//fun_12
Status TraverseList(LinkList& L);//fun_13
Status SqList_Merge(LinkList& LA, LinkList& LB);//fun_beta_1
Status AddList(LinkList& L, ElemType n);//fun_beta_2

int main() {
	LinkList LA, LB;
	CreateLinkList(LA);
	TraverseList(LA);
	CreateLinkList(LB);
	TraverseList(LB);
	SqList_Merge(LA, LB);
	TraverseList(LA);
	DestroyList(LA);
	TraverseList(LA);
	DestroyList(LB);
	TraverseList(LB);
	LinkList L;
	InitLinkList(L);
	CreateLinkList(L);
	TraverseList(L);
	ElemType e;
	GetElem(L, 3, e);
	std::cout << e << std::endl;
	std::cout<<LocateElem(L, e)<<std::endl;
	AddList(L, 11);
	TraverseList(L);
	PriorElem(L, 3, e);
	std::cout << e << std::endl;
	NextElem(L, 4, e);
	std::cout << e << std::endl;
	LinkList L;
	InitLinkList(L);
	CreateLinkList(L);
	TraverseList(L);
	ListDelete(L, L.length);
	TraverseList(L);
	ListDelete(L, 1);
	TraverseList(L);
	ListDelete(L, 3);
	TraverseList(L);
	ListInsert(L, 1, 23);
	TraverseList(L);
	ListInsert(L, L.length+1, 111);
	TraverseList(L);
	ListInsert(L, 3, 666);
	TraverseList(L);
	ClearList(L);
	if (ListEmpty(L)) {
		std::cout << "芜湖起飞" << std::endl;
	}
	TraverseList(L);
	DestroyList(L);
	TraverseList(L);
	return 0;
}

Status InitLinkList(LinkList& L) {
	//有待优化？
	if ( !L.end || L.length >= 0) {
		std::cerr << "您可能重复进行了初始化单链表操作，请问您是否仍要继续执行此操作?" << std::endl;
		std::cout << "输入‘1’以继续进行初始化操作，输入‘0’以退出执行初始化操作。\n请在此输入：" << std::ends;
		int temp;
		std::cin >> temp;
		if (temp) {
			DestroyList(L);
			L.length = 0;
		}
		else {
			return ERROR;
		}
	}
	else {
		L.head = nullptr;
		L.end = nullptr;
		L.length = 0;
	}
	//结束
	return OK;
}

Status CreateLinkList(LinkList& L) {
	if (InitLinkList(L) == ERROR) {
		return ERROR;
	}
	std::cout << "请输入线性表的长度n：";
	int i;
	std::cin >> i;
	if (i <= 0) {
		std::cerr << "输入的数字不合法。" << std::endl;
		return ERROR;
	}
	L.length = i;
	std::cout << "请选择您要添加的方式：\n（输入数字‘1’以选择前插法，输入数字‘0’以选择后插法。" << std::endl;
	int temp;
	std::cin >> temp;
	if (temp) {
		LNode* node_ZERO;
		std::cout << "请输入创建的线性表的各个元素。\n" << "共" << i << "个元素：" << std::endl;
		for (int n = 0; n < L.length; ++n) {
			LNode* node_temp = (LNode*)malloc(sizeof(LNode));
			if (!node_temp) {
				std::cerr << "申请内存空间失败" << std::endl;
				exit(ERROR);
			}
			std::cin >> node_temp->elem;
			if (!n) {
				L.head = node_temp;
				L.head->next = nullptr;
				L.end = node_temp;
			}
			else {
				node_ZERO = L.head;
				L.head = node_temp;
				node_temp->next = node_ZERO;
			}
		}
	}
	else {
		LNode** node_ZERO = nullptr;
		std::cout << "请输入创建的线性表的各个元素。\n" << "共" << i << "个元素：" << std::endl;
		for (int n = 0; n < L.length; ++n) {
			LNode* node_temp = (LNode*)malloc(sizeof(LNode));
			if (!node_temp) {
				std::cerr << "申请内存空间失败" << std::endl;
				exit(ERROR);
			}
			std::cin >> node_temp->elem;
			if (!n) {
				L.head = node_temp;
				L.head->next = 0;
				L.end = node_temp;
				node_ZERO = &(L.head->next);
			}
			else {
				*node_ZERO = node_temp;
				L.end = node_temp;
				node_temp->next =0;
				node_ZERO = &((*node_ZERO)->next);
			}
		}
	}
	return OK;
}

Status DestroyList(LinkList& L)
{
	LNode* temp, * p1;
	p1 = L.head;
	if (!p1) {
		std::cerr << "要销毁的单链表不存在。" << std::endl;
		return ERROR;
	}
	while (p1) {
		temp = p1;
		p1 = p1->next;
		free(temp);
	}
	L.head = 0;
	L.end = 0;
	L.length = -1;
	return OK;
}

Status ClearList(LinkList& L) {
	DestroyList(L);
	L.length = 0;
	return OK;
}

Status ListEmpty(LinkList& L) {
	return L.head ? false : true;
}

Status ListLength(LinkList& L) {
	return L.length;
}

Status GetElem(LinkList& L, int i, ElemType& e) {
	if (!L.head) {
		std::cerr << "要查询的单链表不存在。" << std::endl;
		return ERROR;
	}
	if (i > L.length || 0 > i) {
		std::cerr << "输入的数字不合法。" << std::endl;
		return ERROR;
	}
	LNode* node_T = L.head;
	for (int n = 1; n < i; ++n) {
		node_T = node_T->next;
	}
	e = node_T->elem;
	return OK;
}

Status LocateElem(LinkList& L, int e) {
	if (!L.head) {
		std::cerr << "要查询的单链表不存在。" << std::endl;
		return ERROR;
	}
	LNode* node_T = L.head;
	int i = 0;
	while (node_T) {
		++i;
		if (node_T->elem == e) {
			return i;
		}
		node_T = node_T->next;
	}
	return 0;
}

Status PriorElem(LinkList& L, int cur_e, ElemType& pre_e) {
	if (!L.head) {
		std::cerr << "要查询的单链表不存在。" << std::endl;
		return ERROR;
	}
	LNode* node_T = L.head;
	LNode* temp =0;
	int i = -1;
	while (node_T) {
		++i;
		if (node_T->elem == cur_e) {
			break;
		}
		temp = node_T;
		node_T = node_T->next;
	}
	if (i) {
		pre_e = temp->elem;
	}
	else {
		return ERROR;
	}
	return OK;
}

Status NextElem(LinkList& L, int cur_e, ElemType& next_e) {
	if (!L.head) {
		std::cerr << "要查询的单链表不存在。" << std::endl;
		return ERROR;
	}
	LNode* node_T = L.head;
	int i = 0;
	while (node_T) {
		++i;
		if (node_T->elem == cur_e) {
			break;
		}
		node_T = node_T->next;
	}
	if (i < L.length) {
		next_e = node_T->next->elem;
	}
	else {
		return ERROR;
	}
	return OK;
}

Status ListInsert(LinkList& L, int i, ElemType e) {
	if (!L.head) {
		std::cerr << "要查询的线性表不存在。" << std::endl;
		return ERROR;
	}
	if (1 > i && L.length+1 < i) {
		std::cerr << "输入的数字不合法。" << std::endl;
		return ERROR;
	}
	LNode* temp = L.head;
	LNode* node_temp = (LNode*)malloc(sizeof(LNode));
	if (!node_temp) {
		std::cerr << "申请内存空间失败" << std::endl;
		exit(ERROR);
	}
	node_temp->elem = e;
	if(i ==1){
		L.head = node_temp;
		node_temp->next = temp;
	}
	else {
		for (int n = 1; n < i-1; ++n) {
			temp = temp->next;
		}
		LNode* temp_1 = temp->next;
		temp->next = node_temp;
		node_temp->next = temp_1;
	}
	++L.length;
	return OK;
}

Status ListDelete(LinkList& L, int i) {
	if (!L.head) {
		std::cerr << "要查询的线性表不存在。" << std::endl;
		return ERROR;
	}
	if (!L.length) {
		std::cerr << "要查询的线性表为空。" << std::endl;
		return ERROR;
	}
	if (1 > i && L.length < i) {
		std::cerr << "输入的数字不合法。" << std::endl;
		return ERROR;
	}
	LNode* temp = L.head;
	if (i == 1) {
		L.head = L.head->next;
		free(temp);
	}
	else {
		for (int n = 1; n < i - 1; ++n) {
			temp = temp->next;
		}
		LNode* temp_1 = temp->next;
		LNode* temp_2 = temp_1->next;
		free(temp_1);
		temp->next = temp_2;
	}
	--L.length;
	return OK;
}

Status TraverseList(LinkList& L) {
	if (!L.head) {
		std::cerr << "要遍历的单链表不存在。" << std::endl;
		return ERROR;
	}
	LNode* temp = L.head;
	std::cout << "以下是存储在单链表的内容：" << std::endl;
	while (temp) {
		std::cout << temp->elem << std::ends;
		printf("	");
		temp = temp->next;
	}
	std::cout << std::endl;
	return OK;
}

Status SqList_Merge(LinkList& LA, LinkList& LB) {
	if (!LA.head || !LB.head) {
		std::cerr << "要合并的线性表不存在。" << std::endl;
		return ERROR;
	}
	LNode* node_T2 = LB.head;
	int j = 0;
	for (int i = 0; i < LB.length; ++i) {
		if (!LocateElem(LA, node_T2->elem)) {
			LNode* node_temp = (LNode*)malloc(sizeof(LNode));
			if (!node_temp) {
				std::cerr << "申请内存空间失败" << std::endl;
				exit(ERROR);
			}
			node_temp->elem = node_T2->elem;
			LA.end->next = node_temp;
			node_temp->next = 0;
			LA.end = LA.end->next;
			++LA.length;
		}
		node_T2 = node_T2->next;
	}
	return OK;
}

Status AddList(LinkList& L, ElemType n) {
	if (!L.head) {
		std::cerr << "要查询的线性表不存在。" << std::endl;
		return ERROR;
	}
	LNode* node_temp = (LNode*)malloc(sizeof(LNode));
	if (!node_temp) {
		std::cerr << "申请内存空间失败" << std::endl;
		exit(ERROR);
	}
	node_temp->elem = n;
	L.end->next = node_temp;
	node_temp->next = 0;
	L.end = L.end->next;
	++L.length;
	return OK;
}