【数据结构】单链表和双向循环链表_循环链表物理上连续吗

动态申请一个节点

SListNode\* BuySListNode(SLTDataType x)
{
	SListNode\* newnode = (SListNode\*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

创建链表

SListNode\* CreateSListNode(int n)
{
	SListNode\* phead = NULL, \* ptail = NULL;
	for (int i = 0; i < n; i++)
	{
		SListNode\* newnode = BuySListNode(i);
		if (phead == NULL)
		{
			ptail = phead = newnode;
		}
		else
		{
			ptail->next = newnode;
			ptail = newnode;
		}
	}
	return phead;
}

单链表打印

void SListPrint(SListNode\* phead)
{
	SListNode\* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

单链表尾插

//尾插要想改变原来的，就要传地址
void SListPushBack(SListNode\*\* pplist, SLTDataType x)
{
	SListNode\* newnode = BuySListNode(x);
	if (\*pplist == NULL)
	{
		\*pplist = newnode;
	}
	else
	{
		SListNode\* cur = \*pplist;
		while (cur->next != NULL)
		{
			cur = cur->next;
		}
		cur->next = newnode;
	}
}

单链表尾删

void SListPopBack(SListNode\*\* pplist)
{
	assert(\*pplist);
	if ((\*pplist)->next == NULL)
	{
		free(\*pplist);
		\*pplist = NULL;
	}
	else
	{
		SListNode\* ptail = \*pplist;
		while (ptail->next->next != NULL)
		{
			ptail = ptail->next;
		}
		free(ptail->next);
		ptail->next = NULL;
	}
}

单链表头插

void SListPushFront(SListNode\*\* pplist, SLTDataType x)
{
	SListNode\* newnode = BuySListNode(x);
	newnode->next = \*pplist;
	\*pplist = newnode;
}

单链表头删

void SListPopFront(SListNode\*\* pplist)
{
	assert(\*pplist);
	SListNode\* next = (\*pplist)->next;
	free(\*pplist);
	\*pplist = next;
}

注意：在C语言的单链表，关于改变链表的数字的函数传递方式，传的都是地址。如果不传地址的话就不能改变链表的数值。

就如这个例子一样：

void swap(int\* a, int\* b)
{
	int x = \*a;
	\*a = \*b;
	\*b = x;
}
void swap1(int a, int b)
{
	int x = a;
	a = b;
	b = x;
}
int main()
{
	int a = 10;
	int b = 20;
	swap1(a, b);
	printf("a=%d b=%d\n", a, b);
	swap(&a, &b);
	printf("a=%d b=%d\n", a, b);
}

运行结果：

对于第二种方法，传递的是地址，这里直接把地址里面的数字改了

单链表的查找

SListNode\* SListFind(SListNode\* plist, SLTDataType x)
{
	SListNode\* cur = plist;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			printf("找到了\n");
		}
		cur = cur->next;
	}
	printf("找不到\n");
}

单链表在pos位置之后插入x

void SListInsertAfter(SListNode\*\* pplist, SListNode\* pos, SLTDataType x)
{
	assert(pos);
	if (\*pplist == pos)
	{
		SlistPushFront(pplist, x);
	}
	else
	{
		SListNode\* prve = \*pplist;
		while (prve->next != pos)
		{
			prve = prve->next;
		}
		SListNode\* newnode = BuySListNode(x);
		prve->next = newnode;
		newnode->next = pos;
	}
}

单链表删除pos位置之后的值

void SListEraseAfter(SListNode\* pos)
{
	assert(pos);
	if (pos->next == NULL)
	{
		return;
	}
	else
	{
		SListNode\* newNode = pos->next;
		pos->next = newNode->next;
		free(newNode);
	}
}

双向循环链表

初始化

typedef struct ListNode {
	struct ListNode\* prve;
	struct ListNode\* next;
	LTDataType data;
}LTNode;


LTNode\* LTInit() {
	LTNode\* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prve = phead;
	return phead;
}

申请一个新的节点

LTNOde\* BuyListNode(LTDatatype x) {
	LTNode\* node = (LTNode\*)malloc(sizeof(LTNode));
	if (node == NULL) {
		perror("malloc fail");
		exit(-1);
	}
	node->data = x;
	node->next = NULL;

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

}

node->data = x;
node->next = NULL;

[外链图片转存中…(img-qjjDRJLC-1714273482545)]
[外链图片转存中…(img-ReZy2a7l-1714273482545)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！