带有头节点单链表，带有头节点单链表逆置的四种方法

带头结点的单链表

链式存储结构：逻辑上相邻的数据元素，并不要求物理上也相邻；

单链表的代码实现
.h文件

#pragma once
typedef int Elemtype;
typedef struct ListNode
{
	Elemtype data;
	struct ListNode* next;
}Listnode,*Linklist;

//开辟新节点空间
Listnode* Buynode();
//打印函数
void Show(Linklist plist);

//初始化单链表
void Init_list(Linklist plist);

//查找val的前一个结点
Listnode* Search_valprev(Linklist plist, int val);

// 查找val节点
Listnode* Search_val(Linklist plist, int val);

//查找pos的前一个结点
Listnode* Search_prev(Linklist plist,int pos);

//查找pos节点
Listnode* Search_pos(Linklist plist, int pos);

//在当前节点的后面插入数据
bool Insert_next(Linklist plist, ListNode* ptr,Elemtype val);

//头插
bool Insert_head(Linklist plist, int val);

//尾插
bool Insert_tail(Linklist plist, int val);

//按照位置插入
bool Insert_pos(Linklist plist, int pos,int val);

//删除当前节点下一个节点
bool Del_next(Linklist plist,ListNode*ptr);

//删除当前节点的下一个节点；
bool Del_next(Linklist plist, Listnode * ptr);
//头删
bool Del_head(Linklist plist);

//尾删
bool Del_tail(Linklist plist);

//删除pos位置的节点
bool Del_pos(Linklist plist, int pos);

//删除val
bool Del_val(Linklist plist, Elemtype val);
//判空

//删除和val相等的所有节点
bool Del_allsame(Linklist plist);

bool Is_empty(Linklist plist);

//获取长度
int Get_length(Linklist plist);

//清空
bool Clear(Linklist plist);

//销毁
bool Destory(Linklist plist);

.cpp文件

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include "Linklist.h"
Listnode* Buynode()
{
	Listnode* s = (Listnode*)malloc(sizeof(Listnode));
	if (s ==nullptr)
	{
		exit(0);
	}
	s->next = nullptr;
	return s;
}
//打印函数
void Show(Linklist plist)
{
	assert(plist != nullptr);
	for (Listnode*s=plist->next;s!=nullptr;s=s->next)
	{
		printf("%d ",s->data);
	}
	printf("\n");
}

//初始化单链表
void Init_list(Linklist plist)
{
	assert(plist!=nullptr);
	plist->next=nullptr;
	plist->data = 0;
}

//查找val的前一个结点
Listnode* Search_valprev(Linklist plist, int val)
{
	assert(plist != nullptr);
	Listnode* prev = plist;
	Listnode* p = plist->next;
	while (p->data!=val&&p!=nullptr)
	{
		prev = p;
		p = p->next;
	}
	if (p == nullptr)
	{
		prev = nullptr;
	}
	return prev;
}
// 查找val节点
Listnode* Search_val(Linklist plist, int val)
{
	assert(plist!=nullptr);
	Listnode*s=Search_valprev(plist, val);
	if (s == nullptr)
	{
		exit(0);
	}
	return s->next;
}
//查找pos的前一个结点
Listnode* Search_posprev(Linklist plist, int pos)
{
	assert(plist != nullptr);
	assert(pos > 0 && pos <= Get_length(plist)+1);
	int i = 1;//默认0为头节点1为第一个有效节点；
	Listnode* prev = plist;
	Listnode* p = plist->next;
	for (int i =1; i <= Get_length(plist)+1; i++)
	{
		if (i == pos) break;
		prev = p;
		p = p->next;
	}
	return prev;
}
//查找pos节点
Listnode* Search_pos(Linklist plist, int pos)
{
	assert(plist!=nullptr);
	assert(pos > 0 && pos <= Get_length(plist));
	return Search_posprev(plist, pos)->next;
}

//在当前节点的后面插入数据
bool Insert_next(Linklist plist, ListNode* ptr, Elemtype val)
{
	assert(plist!=nullptr&&ptr!=nullptr);
	Listnode* s = Buynode();
	s->data = val;
	s->next = ptr->next;
	ptr->next = s;
	plist->data += 1;
	return true;
}
//头插
bool Insert_head(Linklist plist, int val)
{
	assert(plist != nullptr);
	return Insert_next(plist, plist, val);
}

//尾插
bool Insert_tail(Linklist plist, int val)
{
	assert(plist!=nullptr);
	if (Is_empty(plist))
	{
		return Insert_next(plist, plist, val);
	}
	Listnode* s = Search_pos(plist, Get_length(plist));
	return Insert_next(plist, s, val);
}

//按照位置插入
bool Insert_pos(Linklist plist, int pos, int val)
{
	assert(plist!=nullptr);
	Listnode* s = Search_posprev(plist, pos);
	return Insert_next(plist, plist, val);
}

//删除当前节点的下一个节点；
bool Del_next(Linklist plist,Listnode *ptr)
{
	assert(plist != nullptr&&ptr!=nullptr&&ptr->next!=nullptr);
	Listnode* s = ptr->next;
	ptr->next = s->next;
	free(s);
	s->next = nullptr;
	plist->data -= 1;
	return true;
}
//头删
bool Del_head(Linklist plist)
{
	assert(plist != nullptr);
	if (Is_empty(plist))
	{
		return false;
	}
	Listnode* s = plist;
	Del_next(plist, s);
	return true;
}

//尾删
bool Del_tail(Linklist plist)
{
	assert(plist != nullptr);
	if (Is_empty(plist))
	{
		return false;
	}
	Listnode* s = Search_posprev(plist, Get_length(plist));
	Del_next(plist, s);
	return true;
}

//删除pos位置的节点
bool Del_pos(Linklist plist, int pos)
{
	assert(plist!=nullptr);
	if (Is_empty(plist))
	{
		return false;
	}
	Listnode*s=Search_posprev(plist,pos);
	if (s == nullptr)
	{
		return false;
	}
	Del_next(plist, s);
	return true;
}
bool Del_val(Linklist plist,Elemtype val)
{
	assert(plist != nullptr);
	Listnode *s=Search_valprev(plist, val);
	if (s == nullptr) return false;
	return Del_next(plist, s);
}
//删除和val相等的所有节点
bool Del_allsame(Linklist plist,int val)
{
	assert(plist!=nullptr);
	Listnode* p = plist;
	Listnode* q = plist->next;
	while (q != nullptr)
	{
		if (q->data== val)
		{
			q = q->next;
		}
		else
		{
			p = p->next;
			p->data = q->data;
			q = q->next;
		}
	}
	q = nullptr;
	while (p->next!=nullptr)
	{
		Del_next(plist, p);
	}
	return true;
}
//判空
bool Is_empty(Linklist plist)
{
	assert(plist!=nullptr);
	return plist->data == 0;
}

//获取长度
int Get_length(Linklist plist)
{
	assert(plist!=nullptr);
	return plist->data;
}

//清空
bool Clear(Linklist plist)
{
	assert(plist != nullptr);
	while (plist->data != 0)
	{
		Del_head(plist);
	}
	return true;
}

//销毁
bool Destory(Linklist plist)
{
	assert(plist!=nullptr);
	Clear(plist);
	free(plist);
	plist = nullptr;
	return true;
}
int main()
{
	Listnode Head;
	Init_list(&Head);
	int arr[] = { 12,23,34,45,56,67,78,89 };
	int n = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < n; i++)
	{
		Insert_tail(&Head,arr[i]);
	}
	
	Show(&Head);
	printf("有效值的个数为%d\n",Get_length(&Head));
	
	Del_head(&Head);
	Show(&Head);
	printf("有效值的个数为%d\n", Get_length(&Head));
	
	Del_tail(&Head);
	Show(&Head);
	printf("有效值的个数为%d\n", Get_length(&Head));
	
	Del_pos(&Head, 1);
	Show(&Head);
	printf("有效值的个数为%d\n", Get_length(&Head));
	
	Del_val(&Head, 56);
	Show(&Head);
	printf("有效值的个数为%d\n", Get_length(&Head));
	
	Insert_tail(&Head,45);
	Insert_tail(&Head, 45);
	Insert_tail(&Head, 99);
	Show(&Head);
	printf("有效值的个数为%d\n", Get_length(&Head));
	
	Del_allsame(&Head, 45);
	Show(&Head);
	printf("有效值的个数为%d\n", Get_length(&Head));
	return 0;
}

单链表逆置的四种做法

1，三个指针的方法

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<string.h>
#include"Linklist.h"
void Inverse1(Linklist plist)//Inverse反向的意思
{
	assert(plist != nullptr);
	Listnode* p = plist->next;
	Listnode* s = nullptr;
	Listnode* q = nullptr;
	while (p!=nullptr)
	{
		s = p;
		p = p->next;
		s ->next= q;
		q = s;
	}
	plist->next = s;
}
int main()
{
	Listnode Head;
	Init_list(&Head);
	int arr[] = { 12,23,34,45,56,67};
	int n = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < n; i++)
	{
		Insert_tail(&Head, arr[i]);
	}
	Show(&Head);
	printf("有效值的个数为%d\n", Get_length(&Head));
	Inverse1(&Head);
	Show(&Head);
	printf("有效值的个数为%d\n", Get_length(&Head));
	return 0;
}

2，两个指针的头插法

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<string.h>
#include"Linklist.h"
void Inverse2(Linklist plist)//Inverse反向的意思
{
	assert(plist != nullptr);
	Listnode* p = plist->next;
	plist->next = nullptr;
	Listnode* q = nullptr;
	while (p!=nullptr)
	{
		q = p;
		p = p->next;
		q->next = plist->next;
		plist->next = q;
	}
}
int main()
{
	Listnode Head;
	Init_list(&Head);
	int arr[] = { 12,23,34,45,56,67};
	int n = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < n; i++)
	{
		Insert_tail(&Head, arr[i]);
	}
	Show(&Head);
	printf("有效值的个数为%d\n", Get_length(&Head));
	Inverse2(&Head);
	Show(&Head);
	printf("有效值的个数为%d\n", Get_length(&Head));
	return 0;
}

3，用一个栈来帮助你来实现
时间复杂度O（n）
即动态的开辟一个数组来充当栈的先进后出功能（数组的大小和单链表的有效节点个数相同）

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<string.h>
#include"Linklist.h"
void Inverse3(Linklist plist)//Inverse反向的意思
{
	assert(plist!=nullptr);
	 int n = plist->data;
	int *stack=(int *)malloc(sizeof(int)*n);//动态开辟一维数组顶替栈
	Listnode* s = plist->next;
	int i = 0;
	while (s != nullptr)
	{
		stack[i++] = s->data;
		s = s->next;
	}
	s = plist->next;
	n = n - 1;
	while (s != nullptr)
	{
		s->data = stack[n--];
		s = s->next;
	}
}
int main()
{
	Listnode Head;
	Init_list(&Head);
	int arr[] = { 12,23,34,45,56,67};
	int n = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < n; i++)
	{
		Insert_tail(&Head, arr[i]);
	}
	Show(&Head);
	printf("有效值的个数为%d\n", Get_length(&Head));
	Inverse3(&Head);
	Show(&Head);
	printf("有效值的个数为%d\n", Get_length(&Head));
	return 0;
}

4，递归来实现

有头结点的单链表逆置

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<string.h>
#include"Linklist.h"
Listnode* Reverse(Listnode*s)//递归函数
{
	assert(s!=nullptr);
	if (s==nullptr||s->next == nullptr)
	{
		return s;
	}
	else
	{
		Listnode* firstnode = Reverse(s->next);
		s->next->next = s;
		 s->next = nullptr;
		 return firstnode;
	}
}
void Inverse4(Linklist plist)//Inverse反向的意思
{
	assert(plist!=nullptr);
	Listnode* s = plist->next;

	plist->next = Reverse(s);
}
int main()
{
	Listnode Head;
	Init_list(&Head);
	int arr[] = { 12,23,34,45,56,67};
	int n = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < n; i++)
	{
		Insert_tail(&Head, arr[i]);
	}
	Show(&Head);
	printf("有效值的个数为%d\n", Get_length(&Head));
	Inverse4(&Head);
	Show(&Head);
	printf("有效值的个数为%d\n", Get_length(&Head));
	return 0;
}

无头结点的单链表逆置

Listnode* Reverse(Listnode*s)
{
	assert(s!=nullptr);
	if (s==nullptr||s->next == nullptr)
	{
		return s;
	}
	else
	{
		Listnode* firstnode = Reverse(s->next);
		s->next->next = s;
		 s->next = nullptr;
		 return firstnode;
	}
}
void Inverse4(Linklist plist)//Inverse反向的意思
{
	assert(plist!=nullptr);
	Listnode* s = plist;

	plist = Reverse(s);
}
int main()
{
	Listnode *Head;
	Init_list(&Head);
	int arr[] = { 12,23,34,45,56,67};
	int n = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < n; i++)
	{
		Insert_tail(Head, arr[i]);
	}
	Show(Head);
	printf("有效值的个数为%d\n", Get_length(Head));
	Inverse4(Head);
	Show(Head);
	printf("有效值的个数为%d\n", Get_length(Head));
	return 0;
}