数据结构之单链表:不带环,不带头结点

最新推荐文章于 2024-04-26 08:00:00 发布
最新推荐文章于 2024-04-26 08:00:00 发布
阅读量137 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lengxinxuexic/article/details/80226590
版权 
#pragma once
#include<stddef.h>
#include<stdio.h >
typedef char LinkType;
typedef struct LinkNode{
	LinkType data;
	struct LinkNode*next;
}LinkNode; 
void LinkListInit(LinkNode** head);
void LinkListPushBack(LinkNode**head, LinkType value);
void LinkListPopBack(LinkNode**head);
void LinkListPushFront(LinkNode**head, LinkType value);
void LinkListPopFront(LinkNode**head);
LinkNode* LinkListFind(LinkNode*head,LinkType to_find);
void LinkListInsert(LinkNode**head,LinkType value,LinkNode* pos );
void LinkListErase(LinkNode**head, LinkNode*pos);
void LinkListRemove(LinkNode**head, LinkType value);
void LinkListRemoveAll(LinkNode**head, LinkType value);
void LinkListEmpty(LinkNode**head);
int LinkListSize(LinkNode*head);
LinkNode*LinklistGreateNode(LinkType*value);
/**
* @brief 逆序打印单链表.
*
* @param head
*/
LinkNode* LinkListReversePrint(LinkNode* head);

/**
* @brief 不允许遍历链表, 在 pos之前插入
*
* @param head
* @param pos
* @param value
*/
void LinkListInsertBefore(LinkNode** head, LinkNode* pos, LinkType value);

LinkNode* JosephCycle(LinkNode* head, size_t food);

/**
* @brief 单链表逆置
*
* @param head
*/
void LinkListReverse(LinkNode** head);
void LinkListReverse2(LinkNode** head);

/**
* @brief 单链表的冒泡排序
*
* @param head
*/
void LinkListBubbleSort(LinkNode* head);

/**
* @brief 将两个有序链表, 合并成一个有序链表
*
* @param head1
* @param head2
*
* @return
*/
LinkNode* LinkListMerge(LinkNode* head1, LinkNode* head2);

LinkNode* FindMidNode(LinkNode* head);

/**
* @brief 找到倒数第 K 个节点.
*
* @param head
*
* @return
*/
LinkNode* FindLastKNode(LinkNode* head, size_t K);

/**
* @brief 删除倒数第K个节点
*
* @param head
* @param K
*/
void EraseLastKNode(LinkNode** head, size_t K);

/**
* @brief 判定单链表是否带环. 如果带环返回1
*
* @param head
*
* @return
*/
LinkNode* HasCycle(LinkNode* head);

/**
* @brief 如果链表带环, 求出环的长度
*
* @param head
*
* @return
*/
size_t GetCycleLen(LinkNode* head);

/**
* @brief 如果链表带环, 求出环的入口
*
* @param head
*
* @return
*/
LinkNode* GetCycleEntry(LinkNode* head);

/**
* @brief 判定两个链表是否相交, 并求出交点
*
* @param head1
* @param head2
*
* @return
*/
LinkNode* HasCross(LinkNode* head1, LinkNode* head2);

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<Windows.h>
#include"linklist.h"
void LinkListInit(LinkNode**head)
{
	if (head == NULL)
	{
		return;
	}
	*head = NULL;
}
LinkNode*LinkListGreateNode(LinkType value)
{
	LinkNode* ptr = (LinkNode*)malloc(sizeof(LinkNode));
	ptr->data = value;
	ptr->next = NULL;
	return ptr;
}
void LinkListPushBack(LinkNode** head, LinkType value)//需要修改头指针时使用**head，不修改则用*head。
{
	if (head == NULL)
	{
		return;
	}//参数非法
	if (*head == NULL)
	{
		*head = LinkListGreateNode(value);
		return;
	}
	LinkNode*cur = *head;
	while (cur->next != NULL)
	{
		cur = cur->next;
	}

	LinkNode* new_node = LinkListGreateNode(value);
	cur->next = new_node;
}
void LinkListDestoryNode(LinkNode* cur)
{
	free(cur);
}
void LinkListPopBack(LinkNode**head)
{
	if (head == NULL)
	{
		return;
	}//参数非法
	if (*head == NULL)
	{
		return;
	}
	LinkNode*cur = *head;
	while (cur->next == NULL)
	{
		LinkListDestoryNode(cur);
		*head = NULL;
		return;
	}
	while (cur->next != NULL)
	{
		if (cur->next->next == NULL)
		{
			LinkNode* to_delete = cur->next;
			cur->next = NULL;
			LinkListDestoryNode(to_delete);
		}
		else
			cur = cur->next;
		
	}
}
void LinkListPushFront(LinkNode**head, LinkType value)
{
	 if (head == NULL)
	{
		return;
	}//参数非法
	if (*head == NULL)
	{
		*head = LinkListGreateNode(value);
		return;
	}
	LinkNode* new_node=LinkListGreateNode(value);
	new_node->next = *head;
	*head = new_node;
}
void LinkListPopFront(LinkNode**head)
{
	if (head == NULL)
	{
		return;
	}//参数非法
	if (*head == NULL)
	{
		return;
	}
	LinkNode*cur = *head;
	while (cur->next == NULL)
	{
		LinkListDestoryNode(cur);
		*head = NULL;
		return;
	}
	*head = (*head)->next;
	LinkListDestoryNode(cur);
}
LinkNode* LinkListFind(LinkNode*head,LinkType to_find)
{
	if (head == NULL)
	{
		return NULL;
	}//参数非法
	LinkNode*cur = head;
	while (cur){
		if (cur->data== to_find)
		{ 
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
void LinkListInsert(LinkNode** head,LinkType value,LinkNode*pos)//在任意位置插入数据
{
	 if (head == NULL)
	{
		return;
	}//参数非法
	if (*head == NULL)
	{
		*head = LinkListGreateNode(value);
		return;
	}
	if (pos == NULL)
	{
		LinkListPushBack(head, value);
	}
	LinkNode*cur = *head;
	while (cur->next != NULL)
	{
		if (cur->next == pos)
		{
			LinkNode*new_node = LinkListGreateNode(value);
			new_node->next = pos;
			cur->next = new_node;
			return;
		}
		else
			cur = cur->next;
	}

	return;
}
void LinkListErase(LinkNode**head, LinkNode*pos)
{
	if (head == NULL||pos==NULL)
	{
		return;
	}//参数非法
	if (*head == NULL)
	{
		return;
	}
	if (*head == pos)
	{
		LinkNode*to_delete = pos;
		*head = (*head)->next;
		LinkListDestoryNode(to_delete);
		return;
	}
	LinkNode*cur = *head;
	LinkNode*to_delete = pos;
	while (cur->next != NULL)
	{
		if (cur->next == pos)
		{
			cur->next = pos->next;
			LinkListDestoryNode(to_delete);
			return;
		}
		else
			cur = cur->next;
	}
	return;
}
void LinkListRemove(LinkNode**head, LinkType value)
{
	if (head == NULL)
	{
		return;
	}//参数非法
	LinkNode*pos = LinkListFind((*head), value);
	LinkListErase(head, pos);
	return;
}
void LinkListRemoveAll(LinkNode**head, LinkType value)
{
	if (head == NULL)
	{
		return;
	}//参数非法
	while (1)
	{
		LinkNode*pos = LinkListFind((*head), value);
		if (pos == NULL)
		{
			break;
		}
		LinkListErase(head, pos);
	}
	return;
}
void LinkListEmpty(LinkNode**head)
{

	if (head == NULL)
	{
		return;
	}//参数非法
	if (*head == NULL)
	{
		return;
	}
	LinkNode*cur = *head;
	while (cur != NULL)
	{
		LinkNode*to_delete = cur;
		cur = cur->next;
		LinkListDestoryNode(to_delete);
	}
	(*head) = NULL;
}
int LinkListSize(LinkNode*head)
{
	int count = 1;
	if (head == NULL)
	{
		return -1;
	}//参数非法

	
	LinkNode*cur = head;
	if (cur->next == NULL)
	{
		return count;
	}
	while (cur != NULL)
	{
		count++;
		cur = cur->next;
	}
	return count;
}

/
void LinkListPrintChar(LinkNode*head, const char* msg)
{
	printf("*****++++++++++*****++++++++++*****++++++++++*****++++++++++*****\n");
	printf("[%s]:",msg);
	LinkNode*cur = head;
	for (; cur != NULL; cur = cur->next)
	{
		printf("[%c:%p]->", cur->data, cur);
	}
	printf("[NULL]");
	printf("\n");
}
/**
* @brief 逆序打印单链表.
*
* @param head
*/

LinkNode* LinkListReversePrint(LinkNode* head)
{
	if (head == NULL||head->next==NULL)
	{
		return NULL;
	}//参数非法
	LinkNode*rev = NULL;//定义一个逆向指针
	LinkNode*cur = head;
	while (cur != NULL)
	{
		LinkNode*temp = cur;//保存第n个节点
		cur = cur->next;//指向n+1个节点
		temp->next = rev;//销毁n指向下一个的指针
		rev = temp;//反指向第n个节点
	}
	return rev;
}

/**
* @brief 不允许遍历链表, 在 pos之前插入
*
* @param head
* @param pos
* @param value
*/
void LinkListInsertBefore(LinkNode**head,LinkNode* pos, LinkType value)
{
	if (head == NULL||pos==NULL)
	{
		return;
	}//参数非法
	if (*head == NULL)
	{
		*head = LinkListGreateNode(value);
		return;
	}
	LinkNode*new_node = LinkListGreateNode(pos->data);
	pos->data = value;
	new_node->next = pos->next;
	pos->next = new_node;
}待修改

LinkNode* JosephCycle(LinkNode* head, size_t food)//约瑟夫环
{
	if (head == NULL)
	{
		return NULL;
	}
	if (food == 0)
	{
		return NULL;
	}
	LinkNode*cur = head;
	while (cur != cur->next)
	{
		size_t i= 0;
		for (; i < food; ++i)
		{
			cur = cur->next;
		}
		LinkNode*to_delete = cur->next;//
		cur->next = to_delete->next;
		LinkListDestoryNode(to_delete);
	}
	return cur;
}

/**
* @brief 单链表逆置
*
* @param head
*/
void LinkListReverse(LinkNode** head)
{
	if (head == NULL )
	{
		return ;
	}//参数非法
	if (*head == NULL || (*head)->next == NULL)
	{
		return;
	}
	LinkNode*cur = *head;
		while (cur->next != NULL)
		{
			LinkNode*to_delete = cur->next;
			cur->next = to_delete->next;
			to_delete->next = *head;
			*head = to_delete;
		}
}
void LinkListReverse2(LinkNode** head)
{
	if (head == NULL)
	{
		return;
	}//参数非法
	if (*head == NULL || (*head)->next == NULL)
	{
		return;
	}
	LinkNode*prev = *head;
	LinkNode*cur = (*head)->next;
	prev->next = NULL;
	while (cur != NULL)
	{
		LinkNode*next = cur->next;
		cur->next = prev;
		prev = cur;
		cur = next;
	}
	*head = prev;
}
void swap(LinkType *x, LinkType *y)
{
	LinkType temp = 0;
	temp = *x;
	*x = *y;
	*y = temp;
}
/**
* @brief 单链表的冒泡排序
*
* @param head
*/
void LinkListBubbleSort(LinkNode* head)
{
	if (head == NULL)
	{
		return;
	}//参数非法
	LinkNode*cur = head;
	LinkNode*tail = NULL;
	for (; cur != NULL;cur=cur->next)
	{
		LinkNode*pos = head;
		for (; pos->next != tail;pos=pos->next)
		{
			if (pos->data > pos->next->data)
			{
				swap(&pos->data, &pos->next->data);
				/*LinkType tmp = 0;
				tmp = pos->data;
				pos->data = pos->next->data;
				pos->next->data = tmp;*/
			}
		}
		tail = pos;
	}
}

/**
* @brief 将两个有序链表, 合并成一个有序链表
*
* @param head1
* @param head2
*
* @return
*/
LinkNode* LinkListMerge(LinkNode* head1, LinkNode* head2)
{
	LinkNode*cur1 = head1;
	LinkNode*cur2 = head2;
	LinkNode*new_head = NULL;
	LinkNode*new_tail = NULL;
	while (cur1 != NULL&&cur2 != NULL)
	{
		if (cur1->data <= cur2->data)
		{
			if (new_head == NULL)
			{
				new_head = new_tail = cur1;
			}
			else
			{
				new_tail->next = cur1;
				new_tail = new_tail->next;
			}
			cur1 = cur1->next;
		}
		else if (cur1->data>cur2->data)
		{
			if (new_head == NULL)
			{
				new_tail = new_tail = cur2;
			}
			else
			{
				new_tail->next = cur2;
				new_tail = new_tail->next;
			}
			cur2 = cur2->next;
		}
	}
	if (cur1 != NULL)
	{
		new_tail->next = cur1;
	}
	else
	{
		new_tail->next = cur2;
	}
	return new_head;
}

LinkNode* FindMidNode(LinkNode* head)
{
	if (head == NULL)
	{
		return NULL;
	}//参数非法
	LinkNode*slow = head;
	LinkNode*fast = head;
	while (fast->next != NULL && fast != NULL)
	{
		slow = slow->next;
		fast = fast->next->next;
	}
	return slow;
}

/**
* @brief 找到倒数第 K 个节点.
*
* @param head
*
* @return
*/
LinkNode* FindLastKNode(LinkNode* head, size_t k)
{
	if (head == NULL)
	{
		return NULL;
	}//参数非法
	LinkNode*slow = head;
	LinkNode*fast = head;
	while (k--)
	{
		fast = fast->next;
	}
	while ( fast != NULL)
	{
		slow = slow->next;
		fast = fast->next;
	}
	return slow;

}

/**
* @brief 删除倒数第K个节点
*
* @param head
* @param K
*/
void EraseLastKNode(LinkNode** head, size_t K)
{
	if (head == NULL)
	{
		return;
	}//参数非法
	if (*head == NULL)
	{
		return;
	}
	LinkNode*p = NULL;
	p = FindLastKNode(*head, K);
	LinkListErase(head, p);

}


/**
* @brief 判定单链表是否带环. 如果带环返回1
*
* @param head
*
* @return
*/
LinkNode* HasCycle(LinkNode* head)
{
	if (head == NULL)
	{
		return NULL;
	}//参数非法
	LinkNode*slow = head;
	LinkNode*fast = head;
	while (fast != NULL&&fast->next != NULL)
	{
		if (fast == slow)
		{
			return slow;
		}
		else
		{
			fast = fast->next->next;
			slow = slow->next;
		}
	}
	return NULL;
}

/**
* @brief 如果链表带环, 求出环的长度
*
* @param head
*
* @return
*/
size_t GetCycleLen(LinkNode* head)
{
	if (head == NULL)
	{
		return 0;
	}//参数非法
	LinkNode*slow = head;
	LinkNode*fast = head;
	size_t sz = 1;
	while (fast != NULL&&fast->next != NULL)
	{
		if (fast == slow)
		{
			LinkNode*get = slow;
			slow = slow->next;
			for (; slow != get; slow = slow->next)
			{
				sz ++;
			}
			return sz;
		}
		else
		{
			fast = fast->next->next;
			slow = slow->next;
		}
	}
	return 0;
}

/**
* @brief 如果链表带环, 求出环的入口
*
* @param head
*
* @return
*/
LinkNode* GetCycleEntry(LinkNode* head)
{
	LinkNode*meet = HasCycle(head);
	if (meet == NULL)
	{
		return NULL;
	}
	LinkNode*cur1 = head;
	LinkNode*cur2 = meet;
	while (cur1 != cur2)
	{
		cur1 = cur1->next;
		cur2 = cur2->next;
	}
	return cur1;
}

/**
* @brief 判定两个链表是否相交, 并求出交点
*
* @param head1
* @param head2
*
* @return
*/
LinkNode* HasCross(LinkNode* head1, LinkNode* head2)
{
	if (head1 == NULL || head2 == NULL)
	{
		return NULL;
	}
	size_t size1 = Linklistsize(head1);
	size_t size2 = Linklistsize(head2);
	LinkNode*cur1 = head1;
	LinkNode*cur2 = head2;
	if (size1 < size2)
	{
		size_t i = 0;
		for (; i < size2 - size1; ++i)
		{
			cur2 = cur2->next;
		}
	}
	else
	{
		size_t i = 0;
		for (; i < size1 - size2; ++i)
		{
			cur1 = cur1->next;
		}
	}
	while (cur1 != cur2)
	{
		cur1 = cur1->next;
		cur2 = cur2->next;
	}
	return cur1;
}
void test()
{
	LinkNode* head=NULL;
	LinkNode* p = NULL;
	LinkNode* p1 = NULL;
	size_t size = 0;
	LinkListInit(&head);
	LinkListInit(&p1);
	 LinkListPushBack(&head,'1');
	 LinkListPushBack(&head, '2');
	 LinkListPushBack(&head, '3');
	 LinkListPushBack(&head, '4');
	 LinkListPushBack(&head, '5');
	 LinkListPushBack(&head, '6');
	 LinkListPushBack(&head, '7');
	 LinkListPushBack(&head, '8');
	 LinkListPushBack(&head, '9');
	 p=head->next = LinkListGreateNode(2);
	 p->next = LinkListGreateNode(3);
	 p->next->next = head;
	 size = GetCycleLen(head);
	 printf("有环:%d\n",size);
	 p1 = GetCycleEntry(head);
	 printf("有环:%c\n", p1->data);
	 p1=HasCycle(head);
	 if (p1 != NULL){
		 printf("有环\n");
	 }
	 else
		 printf("无环！");
	 LinkListPrintChar(p, "   ");
	 EraseLastKNode(&head, 4);
	 LinkListPrintChar(head, "   ");
	 p=FindMidNode( head);
	 LinkListPrintChar(p, "   ");
	 LinkListPushBack(&p1, '1');
	 LinkListPushBack(&p1, '2');
	 LinkListPushBack(&p1, '3');
	 LinkListPushBack(&p1, '4');
	 LinkListPushBack(&p1, '5');
	 p=LinkListMerge(head, p1);
	 LinkListPrintChar(p, "合并");
	 LinkListReverse(&head);
	 LinkListPrintChar(head, "edcba");
	 LinkListBubbleSort(head);
	 LinkListPrintChar(head, "排序abcde");
	 size = LinkListSize(head);
	 printf("元素个数【%d】\n", size);
	 LinkListReverse2(&head);
	 LinkListPrintChar(head, "abcde");
	 LinkListBubbleSort(head);
	 LinkListPrintChar(head, "abcde");
	 p = LinkListFind(head, 'e');
	 p->next = head;
	 JosephCycle(head, 2);
	
	 LinkListPrintChar(head, "abcde");
	 p1=LinkListReversePrint(head);
	 LinkListPrintChar(p1, "abcde");
	 LinkListPopBack(&head);
	 size=LinkListSize(head);
	 printf("元素个数【%d】\n", size);
	 LinkListPrintChar(head, "abcd");
	 LinkListPopFront(&head);
	 LinkListPrintChar(head, "bcd");
	 LinkListPushFront(&head, 'a');
	 LinkListPrintChar(head, "abcd");
	 p = LinkListFind(head, 'f');
	 if (p != NULL){
		 printf("[%c:%p]\n", p->data, p);
	 }
	 else
		 printf("查无此值！");
	 p = LinkListFind(head, 'c');
	 if (p != NULL){
		 printf("[%c:%p]\n", p->data, p);
	 }
	 else
		 printf("查无此值！");
	 LinkListInsert(&head, '0', p);
	 LinkListPrintChar(head, "ab0cd");
	 LinkListInsertBefore(&head, p, 'f');
	 LinkListPrintChar(head, " 不遍历前插  ");
	 LinkListErase(&head, p);
	 LinkListPrintChar(head, "ab0d");
	 LinkListRemove(&head, '0');
	 LinkListPrintChar(head, "abd");
	 LinkListEmpty(&head);
	 LinkListPrintChar(head, "abd");
	 LinkListEmpty(&head);
	 LinkListPrintChar(head, "   ");
}
int main()
{
    test();
	system("pause");
	return 0;
}

一城婳
关注
专栏目录
数据结构（2）—单链表（带头结点和不带头结点）
qq_61914039的博客
08-31 3385
单链表是通过一组任意的存储单元来存储线性表中的数据元素。每个结点都有data数据域（用来存放数据元素）和next指针域（用来存放后继节点的地址）。对于顺序表，单链表可以解决顺序表需要一整个大量的连续的存储单元的缺点，单链表的元素可以离散地分布在存储空间中，即非随机存取的存储结构，不能直接找到表中某个特定的结点，当查找某个特定的结点时，需要从表头开始一个一个遍历。因为单链表附加了指针域，缺点就是存储空间增大。单链表有带头结点和不带头结点两种类型。引入头结点。
链表面试题——不带环问题
木头的博客
09-16 141
注：本篇博客中所使用单链表基本操作函数均可在《线性数据结构——链表》中找到，链接https://blog.csdn.net/lw13572259173/article/details/81281601 从尾到头打印单链表 void PrintTailToHead(pList plist) { //递归 //从最后一个开始打印，直到第一个 //if (pl...
链表面试题（十二）---判断两个都不带环的链表是否相交
05-17 413
一、结构体定义typedef int DataType;typedef struct ListNode//定义结点 { DataType data; struct ListNode* next; }ListNode,*PListNode;typedef struct PList//定义一个成员是指向结点的指针的结构体 { PListNode PHead; }PList,*P
链表带环或不带环的几个经典问题
我的博客
06-26 292
1.给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 public class Solution { public ListNode detectCycle(ListNode head) { Set<ListNode> set = new HashSet<>(); ListNode h1 = head; while(h1!=null){ if(set.contains(h1
带头结点单链表 和 不带头结点单链表的区别
热门推荐
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
11-12 1万+
文章目录不带头结点的操作代码①代码②代码③代码④带头结点的操作代码⑤ 下面的代码中，传递链表时，传的是头指针。如果是带头结点的链表，传递链表时，可以传头结点，具体可以看看 C语言实现-线性表的链式存储(单链表) 带头结点单链表 和 不带头结点单链表的区别： 带头结点单链表，在进行插入、删除操作时，不需要改变链表头指针。 不带头结点的单链表，在进行插入、删除操作时，可能会涉及到链表头指针的修改（所以链表作为参数传递时，传递的是头指针的引用，具体可看代码④中head_insert方法中的指针变量带了
数据结构（不带头结点的单链表）
wfea_lff的博客
11-26 3160
数据结构 单链表 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据 在写单链表的时候，需要对结构体有一定的了解（这里就不做过多的结构体介绍） 不带头结点的单链表 头结点一般在栈区或者数据区开辟且头结点不存储...
【数据结构】带与不带头节点的单链表
m0_74195174的博客
04-26 1079
带头节点的单链表通过引入一个额外的头节点，简化了链表的操作和管理，提高了链表的稳定性和可扩展性。在实际应用中，根据具体需求选择是否使用带头节点的单链表是一个重要的设计决策。不带头节点的单链表是一种简洁、直接的数据结构，它通过直接操作数据节点来实现数据的存储和访问。虽然在一些操作上可能相对复杂，但其动态分配和链式存储的特性使其在许多应用中仍然非常有用。在选择使用不带头节点的单链表时，需要权衡其操作复杂度和内存使用的优势与劣势。这篇文章到这里就结束了如果觉得这篇博客对你有用的话，别忘记三连哦。
C语言数据结构——单链表(不带头)
qq_65980796的博客
02-13 2568
一、单链表：1.1 概念、1.2 链表结构分析、1.3 单链表的基本操作、1.4 单链表的基本操作源码。
数据结构：单链表——带头结点与不带头结点步骤详解
qq_41623154的博客
04-19 9793
单链表：带头结点与不带头结点详解 这两天回顾下链表的知识，关于单链表带头结点和不带头结点有点迷糊了，就去网上查询了下，结果查完心态都炸了。看的整个人更懵逼了！！！ 网上大部分对于带头结点和不带头结点的文章，对不带头结点的链表的表头插入结点的代码，都是错的。我简单截几个图： 正确的步骤应该如下 x->next = head;//此处x是待插入结点 head = x; 下面我们讲下具体...
数据结构——单链表-不带头结点尾插法
qq_25368751的博客
08-15 2961
#include<stdio.h> #include <malloc.h> typedef struct LNode{ int data; struct LNode *next; }LNode, *LinkList; void creatL(LinkList &L,int n){ LNode *r; r = NULL; L = NULL; for(int i =1;i<=n;i++){ LNode *p = (LinkList)malloc(s...
数据结构作业带或不带头结点链表
06-24
2. **不带头结点的链表**：相比之下，不带头结点的链表没有单独的头结点，第一个节点就是链表的起始。这种实现方式节省了内存，但操作起来稍显复杂。比如，如果链表为空，需要特别处理，因为没有明显的空链表标识。...
复习之数据结构_带头结点的单链表
YY_Song 's blogs
02-03 618
带头结点的单链表带头结点的单链表插入图解头文件(.h)代码文件(.cpp)简单测试参考资料 带头结点的单链表 如果说，顺序表是逻辑相邻，物理也相邻的话，那么链表就是逻辑相邻，物理不一定相邻了。对应在计算机中，顺序表，是开创了一块连续的内存空间，用于存放一定的数据。那么链表开辟的内存空间就不一定是连续的、同一块空间了。 顺序表（不定长）示意图： 单链表（带头结点）示意图： 插入图解 对于插入来说，假定：要插入位置的结点为p；插入新的结点为n。那么到底是先p->next = n->next呢
数据结构 &不带头结点的单链表
csdn_edition的博客
01-21 1983
不带头结点的单链表是线性表的一种链式存储形式，首先来设计它的结构： typedef int ElemType; typedef struct Node { ElemType data; struct Node* next; }LNode,*pLinkList; 首先对于单链表进行判空操作： static void DeterPointNull(pLinkList* list) { assert(list != NULL); if (list == NULL) { printf("list i
数据结构————倒置带头结点单链表操作讲解
m0_64985004的博客
04-03 2731
我们先来实现带头单链表的基本操作： 头文件： #include<stdio.h> #include<assert.h> #include<stdlib.h> typedef int ElemType; typedef struct LNode{ ElemType data; struct LNode*next; }LT,*link; void InitList(Link phead);//初始化 void InsertListfront(Link p
【java毕业设计】校内跑腿业务系统源码（springboot+vue+mysql+说明文档）.zip
11-04
项目经过测试均可完美运行！ 环境说明： 开发语言：java jdk：jdk1.8 数据库：mysql 5.7+ 数据库工具：Navicat11+ 管理工具：maven 开发工具：idea/eclipse
【java毕业设计】大学志愿填报系统源码（springboot+vue+mysql+说明文档）.zip
11-04
项目经过测试均可完美运行！ 环境说明： 开发语言：java jdk：jdk1.8 数据库：mysql 5.7+ 数据库工具：Navicat11+ 管理工具：maven 开发工具：idea/eclipse
基于java的网吧管理系统答辩PPT.pptx
11-04
基于java的网吧管理系统答辩PPT.pptx
基于java的基于SSM架构的网上书城系统答辩PPT.pptx
最新发布
11-04
基于java的基于SSM架构的网上书城系统答辩PPT.pptx
tornado-6.1-cp37-cp37m-win32.whl
11-04
tornado-6.1-cp37-cp37m-win32.whl
C++实现的带头结点单链表操作全解析：增删改查
本文档详细介绍了如何使用C++实现带头结点的单链表操作，涵盖了单链表在数据结构中的关键功能。作者MadeByFred韩提供了丰富的链表操作方法，包括但不限于： 1. **节点添加**: - `bool addNode()`：预设三个节点并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值