数据结构之链表

.h文件

//#pragma once
#ifndef MYLINKLIST_H_
#define MYLINKLIST_H_

#pragma region Header
#include <iostream>
#include <stdio.h>
#pragma endregion

#pragma region Some rudimentary definition
using ElemType = int;
constexpr int MAXSIZE = 1000;
#pragma endregion

#pragma region Struct of Node
struct LNode {
	ElemType data;
	struct LNode* next;
};/*单链表*/

struct DuLNode {
	ElemType data;
	struct DuLNode* prior;
	struct DuLNode* next;
};/*双向链表*/
#pragma endregion

#pragma region Function of Single Linked List
LNode* InitList_L(int n = 0);
int CreatList_L_Head(LNode* Head, int n);
int CreatList_L_Tail(LNode* Head, int n);
LNode* GetElem_L(ElemType& e, LNode* Head, int i);
LNode* LocateElem_L(LNode* Head, ElemType e, int (*compare)(ElemType, ElemType));
int ListInsert_L(LNode* Head, int i, ElemType e);
int ListDelete_L(LNode* Head, int i, ElemType& e);
int ClearList_L(LNode* Head);
int DestoryList_L(LNode* Head);
int ListLength_L(LNode* Head);
//int MergeList_L(LNode La, LNode Lb, LNode& Lc);
int Union_L(LNode& LA, LNode LB);
#pragma endregion

#pragma region Function of Double Linked List
DuLNode* InitList_DL(int n);
DuLNode* GetElem_DL(ElemType& e, DuLNode* Head, int i);
int ListInsert_DL(DuLNode* Head, int i, ElemType e);
int ListDelete_DL(DuLNode* Head, int i, ElemType& e);
#pragma endregion

#pragma region Function of Circular Linked List
/*操作与单链表相似，只需将循环条件是否为NULL改为是否为头节点*/
LNode* InitList_LOOP(int n = 0);
int CreatList_LOOP(LNode* Head, int n);
#pragma endregion

#endif // !MYLINKLIST_H_

.cpp文件

#include "MYLinkList.h"

#pragma region Some rudimentary definition
constexpr int OK = 0;
constexpr int ERROR = -1;
constexpr int TRUE = 1;
constexpr int FALSE = 0;
#pragma endregion

#pragma region Temp Function compare
/* input b */
static int compare_equal(ElemType a, ElemType b) {
	if (a == b) return TRUE;
	else return FALSE;
}
#pragma endregion

#pragma region Function of Single Linked List
/* 初始化单链表 */
LNode* InitList_L(int n) {
	LNode* Head = new LNode;
	Head->data = n;
	Head->next = nullptr;
	return Head;
}

/* 创建单链表 前插法(倒序) */
int CreatList_L_Head(LNode* Head, int n) {
	for (int i = 0; i < n; i++) {
		LNode* p = new LNode;
		std::cin >> p->data;
		p->next = Head->next;
		Head->next = p;
	}
	return 0;
}

/* 创建单链表 后插法(顺序) */
int CreatList_L_Tail(LNode* Head, int n) {
	LNode* temp = Head;
	for (int i = 0; i < n; i++) {
		LNode* p = new LNode;
		std::cin >> p->data;
		p->next = nullptr;
		temp->next = p;
		temp = p;
	}
	return 0;
}

/* 第i位置单链表读取元素值和指针 */
LNode* GetElem_L(ElemType& e, LNode* Head, int i) {
	int j = 1;
	LNode* p = Head->next;
	while (p && (j < i)) {
		p = p->next;
		j++;
	}
	if (!p || j > i) return nullptr;
	e = p->data;
	return p;
}

/* 定位元素e位置 */
LNode* LocateElem_L(LNode* Head, ElemType e, int (*compare)(ElemType, ElemType)) {
	LNode* p = Head;
	while (!compare(p->data, e) && p) {
		p = p->next;
	}
	if (!p) return nullptr;
	return p;
}

/* 第i位置单链表插入 */
int ListInsert_L(LNode* Head, int i, ElemType e) {
	LNode* p = Head;
	int j = 0;
	while (p && j < i - 1) {
		p = p->next;
		j++;
	}
	if (!p || j > i - 1) return ERROR;
	LNode* new_L = new LNode;
	new_L->data = e;
	new_L->next = p->next;
	p->next = new_L;
	return OK;
}

/* 第i位置单链表删除 */
int ListDelete_L(LNode* Head, int i, ElemType& e) {
	LNode* p = Head;
	int j = 0;
	while (p && j < i - 1) {
		p = p->next;
		j++;
	}
	if (!p || j > i - 1) return ERROR;
	LNode* q = p->next;
	p->next = q->next;
	e = q->data;
	delete q;
	return OK;
}

/* 单链表长度 */
int ListLength_L(LNode* Head) {
	LNode* p = Head;
	int Length = 0;
	while (p = p->next) {
		Length++;
	}
	return Length;
}

/* 清空单链表 */
int ClearList_L(LNode* Head) {
	LNode* p = Head->next;
	LNode* q;
	while (p) {
		q = p->next;
		delete p;
		p = q;
	}
	
	Head->next = nullptr;
	return OK;
}

/* 摧毁单链表 */
int DestoryList_L(LNode* Head) {
	ClearList_L(Head);
	delete Head;
	return OK;
}

/* 合并单链表 */
int Union_L(LNode* LA, LNode* LB) {
	int LA_len = ListLength_L(LA);
	int LB_len = ListLength_L(LB);
	ElemType e;

	for (int i = 1; i <= LB_len; i++) {
		GetElem_L(e, LB, i);
		if (LocateElem_L(LA, e, compare_equal) == nullptr) {
			ListInsert_L(LA, ++LA_len, e);
		}
	}
	return OK;
}
#pragma endregion

#pragma region Function of Double Linked List
/* 初始化双向链表 */
DuLNode* InitList_DL(int n) {
	DuLNode* Head = new DuLNode;
	Head->data = n;
	Head->prior = nullptr;
	Head->next = nullptr;
	return Head;
}

/* 第i位置双向链表的元素值和指针 */
DuLNode* GetElem_DL(ElemType& e, DuLNode* Head, int i) {
	int j = 1;
	DuLNode* p = Head->next;
	while (p && (j < i)) {
		p = p->next;
		j++;
	}
	if (!p || j > i) return nullptr;
	e = p->data;
	return p;
}

/* 第i位置双向链表插入 */
int ListInsert_DL(DuLNode* Head, int i, ElemType e){
	ElemType temp;
	DuLNode* p;
	if (!(p = GetElem_DL(temp, Head, i))) return ERROR;
	DuLNode* new_DL = new DuLNode;
	new_DL->data = e;
	new_DL->prior = p->prior;
	p->prior->next = new_DL;
	p->prior = new_DL;
	new_DL->next = p;
	return OK;
}

/* 第i位置双向链表删除 */
int ListDelete_DL(DuLNode* Head, int i, ElemType& e) {
	ElemType temp;
	DuLNode* p;
	if (!(p = GetElem_DL(temp, Head, i))) return ERROR;
	e = p->data;
	p->prior->next = p->next;
	p->next->prior = p->prior;
	delete p;
	return OK;
}
#pragma endregion

#pragma region Function of Circular Linked List
/* 初始化循环链表 */
LNode* InitList_LOOP(int n) {
	LNode* Head = new LNode;
	Head->data = n;
	Head->next = Head;
	return Head;
}

/* 创建循环链表 */
int CreatList_LOOP(LNode* Head, int n) {
	LNode* temp = Head;
	for (int i = 0; i < n; i++) {
		LNode* p = new LNode;
		std::cin >> p->data;
		p->next = Head;
		temp->next = p;
		temp = p;
	}
	return OK;
}
#pragma endregion

小结

学习笔记，欢迎指正。