投稿
  1. 首页
  2. C

数据结构基础-CC++实现单链表（带头结点）

code • 2022-4-14 • C • 阅读 38

数据结构基础-CC++实现单链表（带头结点）,第1张

  1. 定义结构体
/**
 * @brief 链表节点 
 */
typedef struct LinkedNode{
	// 存储数据  
	int data;
	// 下一个节点的地址 
	LinkedNode *next;	
}LinkedNode, *LinkedList;
  1. 初始化
/**
 * @brief 初始化一个带头结点的单链表
 * 
 * @return LinkedList 单链表的头节点
 */
LinkedList initLinkedListHaveHead() {
	// 为单链表申请一块内存空间，最为头节点
	LinkedList list = (LinkedNode *)malloc(sizeof(LinkedNode));
	// 初始化头节点之后无数据
	list -> next = NULL;
	return list;
}
  1. 判空
/**
 * @brief 有头节点的单链表是否为空
 * 
 * @param l 有头节点的单链表
 * @return true 为空
 * @return false 不为空
 */
bool isEmptyHaveHead(LinkedList l) {
	// 有头节点判断头节点的next是否为null
	return l -> next == NULL;
}
  1. 遍历打印
/**
 * @brief 遍历打印带头结点单链表
 * 
 * @param list 有头结点单链表
 */
void haveHeadPrint(LinkedList list) {
	LinkedNode *node = list -> next;
	int i = 0;
	while (node != NULL) {
		cout << "data" << i << "：" << node -> data << "\n" << endl;
		node = node -> next;
		i++;
	}
	
}
  1. 第一个位置插入
/**
 * @brief 有头节点的单链表在第一个位置插入
 * 
 * @param list 有头节点的单链表
 * @param data 要插入的数据
 * @return true 插入成功
 * @return false 插入失败
 */
bool haveHeadInsertToFirst(LinkedList &list, int data) {
	// 如果链表为空不进行插入
	if(list == NULL) {
		return false;
	}
	// 为新节点申请内存空间
	LinkedNode *node = (LinkedNode *)malloc(sizeof(LinkedNode));
	// 新节点数据赋值
	node -> data = data;
	// 新节点的next指针指向头节点的next
	node -> next = list-> next;
	// 头节点的next指向新节点
	// 上面一部和这一步顺序不能调换不然将会丢失头节点之后的所有数据
	list -> next = node;
	return true;
}
  1. 按位查找
/**
 * @brief 有头节点按位查找
 * 
 * @param list 有头节点的单链表
 * @param index 要查找的下标（0开始）
 * @return LinkedNode* 节点指针
 */
LinkedNode* haveHeadGetByIndex(LinkedList &list, int index) {
	// 链表为空无法 *** 作
	if (isEmptyHaveHead(list)) {
		return NULL;
	}

	// 下标不合法
	if (index < 0) {
		return NULL;
	}
	
	// 声明临时节点指针指向点链表的第一个元素下标为0
	LinkedNode *node = list -> next;
	int i = 0;
	// 得到对应位置的节点
	while(node != NULL && i < index) {
		node = node -> next;
		i++;
	}
	
	// 结束循环时i的值小于index的值
	// 证明index的值超过了最大下标返回null
	if(i < index) {
		return NULL;
	}
	
	return node;
}
  1. 后插
/**
 * @brief 节点后插入新节点
 * 
 * @param node 执行后插的节点
 * @param data 插入的数据
 * @return true 让如成功
 * @return false 插入失败
 */
bool insertByNodeAfter(LinkedNode *node, int data) {
	// 节点为null无法 *** 作
	if (node == NULL) {
		return false;
	}
	
	// 为新节点申请内存空间
	LinkedNode *newNode = (LinkedNode *)malloc(sizeof(LinkedNode));

	// 新节点数据赋值
	newNode -> data = data;
	// 新节点的下一个元素为后插节点的下一个元素
	newNode -> next = node -> next;
	// 后插节点的下一个元素为新节点
	node -> next = newNode;
	return true;
}
  1. 前插
/**
 * @brief 节点前插入数据
 * 
 * 因为单链表只能向一个方向查找，所以前插 *** 作可以将前插 *** 作的节点数据更新为要插入的数据，然后在将前插节点的原本的数据进行后插
 * 
 * @param node 前插节点
 * @param data 插入数据
 * @return true 插入成功
 * @return false 插入失败
 */
bool insertByNodeFront(LinkedNode *node, int data) {
	// 节点指针为null无法 *** 作
	if (node == NULL) {
		return false;
	}

	// 将前插节点的数据进行保存
	int nodeData = node -> data;
	// 将前插节点的数据更新为要插入的数据
	node -> data = data;
	// 将前插节点的数据以后插方式插入到链表中
	return insertByNodeAfter(node, nodeData);
}
  1. 按下标插入
/**
 * @brief 带头结点的按位插入
 * 
 * @param list 带头结点的单链表
 * @param index 插入位置的下标
 * @param data 插入的数据
 * @return true 插入成功
 * @return false 插入失败
 */
bool haveHeadInsertByIndex(LinkedList &list, int index, int data) {
	// 下标小于零为非法参数
	if (index < 0) {
		return false;
	}
	
	// 下标等于零直接调用带头节点的单链表的在第一个位置插入的方法
	if (index == 0) {
		haveHeadInsertToFirst(list, data);
		return true;
	}

	// 链表为空无法 *** 作
	if (isEmptyHaveHead(list)) {
		return false;
	}

	// 调用有头节点的按位查找获取插入下标的前一个节点
	LinkedNode *node = haveHeadGetByIndex(list, index - 1);
	
	// 如果返回的节点指针为null则证明下标不合法
	if (node == NULL) {
		return false;
	}
	
	// 直接调用后插方法
	return insertByNodeAfter(node, data);
}
  1. 删除第一个
/**
 * @brief 带头结点删除第一个元素
 * 
 * @param list 到头节点的单链表
 * @return true 删除成功
 * @return false 删除失败
 */
bool haveHeadRemoveFirst(LinkedList &list) {
	// 判断带头结点的单链表是否为空
	bool flag = isEmptyHaveHead(list);
	if (flag) {
		// 为空无法 *** 作
		return false;
	}

	// 将带头结点的额第一个元素及逆行临时保存
	LinkedNode *node = list -> next;
	// 将头节点的next域指向第二个节点
	list -> next = node -> next;
	// 释放第一个节点
	free(node);
	// 删除成功
	return true;
}
  1. 按下标删除
/**
 * @brief 有头节点根据下标删除
 * 
 * @param list 有头节点单链表
 * @param index 下标
 * @return true 删除成功
 * @return false 删除失败
 */
bool haveHeadRemoveByIndex(LinkedList &list, int index) {
	// 链表为空无法 *** 作
	if (isEmptyHaveHead(list)) {
		return false;
	}
	
	// 获取删除节点的上一个节点
	LinkedNode *node = haveHeadGetByIndex(list, index - 1);
	// 上一个节点为空无法 *** 作
	if (node == NULL) {
		return false;
	}

	// 获取删除节点
	LinkedNode *removeNode = node -> next;
	// 将前一节点的next指向删除节点的next
	node -> next = removeNode -> next;
	// 释放删除节点的内存
	free(removeNode);
	// 删除成功
	return true;
}
  1. 按值查找
/**
 * @brief 有头节点的按值获取
 * 
 * @param list 带头结点的单链表
 * @param data 要查找的数据
 * @return LinkedNode* 根据条件查找到的节点
 */
LinkedNode* haveHeadGetValueFirst(LinkedList &list, int data) {
	// 临时指针指向第一个节点
	LinkedNode *node = list -> next;
	while (node != NULL) {
		// 循环如果没到最后一个几点，判断当前节点的数据是否和传入数据相等
		if (node -> data == data) {
			// 相等返回这个节点
			return node;
		}
		// 不相等继续往下一个节点判断
		node = node -> next;
	}
	// 整个链表没找到对应的值返回null
	return NULL;
}
  1. 根据下标修改元素值
/**
 * @brief 有头节点的根据下标修改元素值
 * 
 * @param list 有头结点单链表
 * @param index 下标
 * @param data 目标数据
 * @return true 修改成功
 * @return false 修改失败
 */
bool haveHeadModifyByIndex(LinkedList &list, int index, int data) {
	// 链表为空无法 *** 作
	if (isEmptyHaveHead(list)) {
		return false;
	}
	// 非法参数
	if (index < 0) {
		return false;
	}
	// 获取要修改位置节点的前一个节点
	LinkedNode *node = haveHeadGetByIndex(list, index - 1);
	// 节点为null下标为非法参数
	if (node == NULL) {
		return false;
	}
	// 将修改位置的数据赋值为新的值
	node -> next -> data = data;
	// 修改成功
	return true;
}
  1. 将链表中的某个值全部修改成另一个值
/**
 * @brief 有头结点将链表中的某个值全部修改成另一个值
 * 
 * @param list 有头结点单链表
 * @param source 原值
 * @param target 目标值
 * @return true 修改成功
 * @return false 修改失败
 */
bool haveHeadModifyByValue(LinkedList &list, int source, int target) {
	// 链表为空无法 *** 作
	if (isEmptyHaveHead(list)) {
		return false;
	}

	// 临时变量指向链表的第一个元素
	LinkedNode *node = list -> next;
	while (node != NULL) {
		if (node -> data == source) {
			// 如果当前节点的数据和传入的source相同，则修改成target
			node -> data = target;
		}
		node = node -> next;
	}
	// 修改成功
	return true;
}
  1. 尾插法
/**
 * @brief 带头结点的尾插法
 * 
 * @param dataArr 初始数据数组
 * @param initLength 初始化长度
 * @return LinkedList 初始化完成的带头结点的单链表
 */
LinkedList haveHeadCreateByTail(int dataArr[], int initLength) {
	// 初始化一个带头结点的单链表
	LinkedList list = initLinkedListHaveHead();
	// 新节点指针
	LinkedNode *node = list;
	// 表尾指针
	LinkedNode *tail = list;
	for (int i = 0; i < initLength; i++) {
		// 新节点申请内存空间
		node = (LinkedNode*)malloc(sizeof(LinkedNode));
		// 新节点数据
		node -> data = dataArr[i];
		// 新节点的next只想null
		node -> next = NULL;
		// 表尾指针的next指向新节点
		tail -> next = node;
		// 将尾指针指向当前节点
		tail = node;
	}
	// 返回这个单链表
	return list;
}
  1. 头插法
/**
 * @brief 有头节点的头插法
 * 
 * @param dataArr 初始数据
 * @param initLength 初始化长度
 * @return LinkedList 初始化完成的有头节点的单链表
 */
LinkedList haveHeadCreateByHead(int dataArr[], int initLength) {
	// 初始化一个空的带头结点的单链表
	LinkedList list = initLinkedListHaveHead();
	for (int i = 0; i < initLength; i++) {
		// 为新节点申请内存kong'jian
		LinkedNode *node = (LinkedNode*)malloc(sizeof(LinkedNode));
		// 新节点数据赋值
		node -> data = dataArr[i];
		if (i == 0) {
			// 头插法第一个元素为初始化完最终的表尾元素，所以next为NULL
			node -> next = NULL;
		} else {
			// 出第一个元素外其他元素next指向头节点的next
			node -> next = list -> next;
		}
		// 头节点指向新节点
		list -> next = node;
	}
	// 返回这个带头节点的单链表
	return list;
}
注：在第一个插入、按下标插入以及删除第一个、按下标删除的 *** 作是可以整合在一起的，但是由于个人习惯将其分开，因为插入删除第一个的时间复杂度都是O(1), 但是下标插入、下标删除都是O(n)，并且在调用方法的时候代码的可用性比较高，简单明了。


若有错误欢迎指正，如有不懂也可相互交流

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/607717.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-04-14
下一篇 2022-04-14

发表评论

登录后才能评论

评论列表（0条）

保存