数据结构二：单链表（C/C++实现）

已于 2023-07-30 21:45:34 修改
阅读量89 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c语言 c++
于 2023-07-30 18:05:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62078117/article/details/132008658
版权

目录

带头结点代码实现（C）：

带头结点代码实现（C++）：

不带头结点代码实现（C）：

不带头结点代码实现（C++）：

测试结果：

总结：

单链表分为带头结点的和不带头结点两种；

带头结点的写代码更方便

带头结点代码实现（C）：

#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;
typedef struct LNode {	//单链表结点
	ElemType data;
	struct LNode* next;
}LNode,*LinkList;

//此处讨论为带头结点的单链表
//尾插法建立单链表，所得到的单链表为顺序
//LinkList* L 等价于 LNode** L，因为要修改指针本身，所以要用到指针的指针
int ListTailInit(LinkList* L)
{
	int x;
	//这里传入的是二级指针，(*L)就是链表的头指针
	(*L) = (LinkList)malloc(sizeof(LNode));//头结点
	if ((*L) == NULL)	return 0;
	(*L)->next = NULL;
	LNode* r = (*L);	//尾指针
	scanf_s("%d", &x);
	while (x != 9999) {	//手动输入数据，建立单链表
		LNode* s = (LNode*)malloc(sizeof(LNode));
		if (s == NULL)	return 0;
		s->data = x;
		r->next = s;
		r = s;	//移动尾指针
		scanf_s("%d", &x);
	}
	r->next = NULL;	//防止脏数据遗留
	return 1;
}
//头插法建立单链表，所得到的单链表为逆序，可用于链表的逆置
int ListHeadInit(LinkList* L)
{
	int x;
	//这里传入的是二级指针，(*L)就是链表的头指针
	(*L) = (LinkList)malloc(sizeof(LNode));//头结点
	if ((*L) == NULL)	return 0;
	(*L)->next = NULL;
	scanf_s("%d", &x);
	while (x != 9999) {	//手动输入数据，建立单链表
		LNode* s = (LNode*)malloc(sizeof(LNode));
		if (s == NULL)	return 0;
		s->data = x;
		s->next = (*L)->next;
		(*L)->next = s;	//从头结点处插入
		scanf_s("%d", &x);
	}
	return 1;
}
//销毁单链表
int ListDestory(LinkList* L)
{
	LNode* p = (*L)->next;//p指向待删除结点
	while (p != NULL) {
		(*L)->next = p->next;
		free(p);
		p = (*L)->next;
	}
	p = (*L);
	free(p);
	p = NULL;	//删除头结点
	(*L) = NULL;
	return 1;
}
//查找第i个结点
LNode* ListSearchNode(LinkList L, int i)
{
	if (i < 1)	return NULL;

	int j = 1;//计数值
	LNode* p = L->next;//p初始指向第一个结点
	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}
	return p;	//返回第i个结点，若i大于表长，返回NULL
}
//按值查找结点
LNode* ListSearchElem(LinkList L, ElemType e)
{
	LNode* p = L->next;//p初始指向第一个结点
	while (p != NULL && p->data != e) {
		p = p->next;
	}
	return p;
}
//求链表表长（头结点不算长度）
int ListLenth(LinkList L)
{
	int len = 0;
	if (L == NULL)	return 0;
	else len++;

	LNode* p = L->next;//p初始指向第一个结点
	if (p == NULL)	return 0;
	while (p->next != NULL) {
		p = p->next;
		len++;
	}
	return len;
}
//第i个位置后插结点e，新结点位于i处
int ListRearInsert(LinkList* L, int i, ElemType e)
{
	LNode* p = ListSearchNode(*L, i - 1);//找到第i-1个结点
	if (p == NULL)	return 0;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL)	return 0;
	s->data = e;
	s->next = p->next;
	p->next = s;		//p后插入结点
	return 1;
}
//第i个位置前插结点e，新结点位于i-1处
int ListFrontInsert(LinkList* L, int i, ElemType e)
{
	LNode* p = ListSearchNode(*L, i - 1);//找到第i-1个结点
	if (p == NULL)	return 0;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL)	return 0;
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;		//实际上是后插结点，只不过数据域交换了
	return 1;
}
//删除第i个结点，并返回删除数据
int ListDeleteNode(LinkList* L, int i, ElemType* e)
{
	LNode* p = ListSearchNode(*L, i - 1);//找到第i-1个结点
	if (p == NULL)	return 0;
	
	LNode* q = p->next;
	if (q == NULL)	return 0;
	p->next = q->next;
	*e = q->data;	//删除结点，返回删除数据
	free(q);
	q = NULL;
	return 1;
}
//删除特定结点e
int ListDeleltNodeP(LinkList* L, ElemType e)
{
	LNode* p = ListSearchElem(*L, e);//找到要删除的p结点
	if (p == NULL)	return 0;

	LNode* q = p->next;//q指向待删除结点的后一个结点
	if (q == NULL) {	//q为NULL，表示p为链表最后一个结点
		//要找到p的前一个结点，才能删除p；单链表只能从头开始找，时间复杂度较高
		LNode* t = *L;
		while (t->next != p) {
			t = t->next;
		}
		//此时t为p的前一个结点
		t->next = NULL;
		free(p);
		p = NULL;	//删除p结点
	}
	else {
		p->next = q->next;
		p->data = q->data;	//覆盖p的数据域，相当于删除p
		free(q);
		q = NULL;
	}
	return 1;
}
//从头输出单链表
void ListPrint(LinkList L)
{
	if (L == NULL || L->next == NULL)	return;
	
	LNode* p = L->next;
	int i = 1;
	while (p != NULL) {
		printf("data[%d]:%d     ", i, p->data);
		p = p->next;	//必须先输出再移动指针
		i++;
	}
	printf("\n");
}



int main()
{
	LinkList L;
	/********************单链表的建立、销毁以及求表长*********************/
	//头插法建立单链表
	printf("请输入数据建立单链表，输入9999表示结束：\n");
	if (ListHeadInit(&L)) {
		printf("头插法建立单链表成功！单链表为：\n");
		ListPrint(L);
	}
	else {
		printf("头插法建立单链表失败！\n");
	}
	//销毁单链表
	if (ListDestory(&L)) {
		printf("原单链表销毁成功！\n");
		ListPrint(L);
	}
	else {
		printf("原单链表销毁失败！\n");
	}
	//尾插法建立单链表
	printf("请输入数据建立单链表，输入9999表示结束：\n");
	if (ListTailInit(&L)) {
		printf("尾插法建立单链表成功！单链表为：\n");
		ListPrint(L);
	}
	else {
		printf("尾插法建立单链表失败！\n");
	}
	printf("单链表长度：%d\n", ListLenth(L));
	/******************************************************************/


	/********************单链表的插入与删除（成功）**********************/
	printf("\n\n\n");
	if (ListRearInsert(&L, 4, 12345)) {	//第4个位置后插元素12345
		printf("第4个位置后插12345成功！新链表为：\n");
		ListPrint(L);
	}
	else {
		printf("第4个位置后插12345失败！\n");
	}
	if (ListFrontInsert(&L, 2, 999)) {	//第2个位置前插元素999
		printf("第2个位置前插999成功！新链表为：\n");
		ListPrint(L);
	}
	else {
		printf("第2个位置前插12345失败！\n");
	}
	int e;
	if (ListDeleteNode(&L, 3, &e)) {	//删除第3个位置的元素
		printf("删除第3个位置元素成功！删除元素为：%d新链表为：\n", e);
		ListPrint(L);
	}
	else {
		printf("删除第3个位置元素失败！\n");
	}
	if (ListDeleltNodeP(&L, 12345)) {	//删除12345元素
		printf("删除12345成功！新链表为：\n");
		ListPrint(L);
	}
	else {
		printf("删除12345失败！\n");
	}
	/******************************************************************/


	/********************单链表的插入与删除（失败）**********************/
	printf("\n\n\n");
	if (ListRearInsert(&L, 10, 12345)) {	//第10个位置后插元素12345
		printf("第10个位置后插12345成功！新链表为：\n");
		ListPrint(L);
	}
	else {
		printf("第10个位置后插12345失败！\n");
	}
	if (ListFrontInsert(&L, 15, 999)) {	//第15个位置前插元素999
		printf("第15个位置前插999成功！新链表为：\n");
		ListPrint(L);
	}
	else {
		printf("第15个位置前插12345失败！\n");
	}
	int temp;
	if (ListDeleteNode(&L, 9, &temp)) {	//删除第9个位置的元素
		printf("删除第9个位置元素成功！删除元素为：%d新链表为：\n", temp);
		ListPrint(L);
	}
	else {
		printf("删除第9个位置元素失败！\n");
	}
	if (ListDeleltNodeP(&L, 12345)) {	//删除12345元素
		printf("删除12345成功！新链表为：\n");
		ListPrint(L);
	}
	else {
		printf("删除12345失败！\n");
	}
	/******************************************************************/

	system("pause");
	return 0;
}

带头结点代码实现（C++）：

#include <iostream>

typedef int ElemType;
typedef struct LNode {	//单链表结点
	ElemType data;
	struct LNode* next;
}LNode,*LinkList;

//此处讨论为带头结点的单链表
//尾插法建立单链表，所得到的单链表为顺序
bool ListTailInit(LinkList& L)
{
	int x;	
	L = new LNode;	//头结点
	if (L == NULL)	return false;
	L->next = NULL;
	LNode* r = L;	//尾指针
	std::cin >> x;
	while (x != 9999) {	//手动输入数据，建立单链表
		LNode* s = new LNode;
		if (s == NULL)	return false;
		s->data = x;
		r->next = s;
		r = s;	//移动尾指针
		std::cin >> x;
	}
	r->next = NULL;	//防止脏数据存留
	return true;
}
//头插法建立单链表，所得到的单链表为逆序，可用于链表的逆置
bool ListHeadInit(LinkList& L)
{
	int x;
	L = new LNode;	//头结点
	if (L == NULL)	return false;
	L->next = NULL;
	std::cin >> x;
	while (x != 9999) {
		LNode* s = new	LNode;
		if (s == NULL)	return false;
		s->data = x;
		s->next = L->next;
		L->next = s;	//从头结点处插入
		std::cin >> x;
	}
	return true;
}
//销毁单链表
bool ListDestory(LinkList& L)
{
	LNode* p = L->next;//p指向待删除结点
	while (p != NULL) {
		L->next = p->next;
		free(p);
		p = L->next;
	}
	p = L;
	free(p);
	p = NULL;	//删除头结点
	L = NULL;
	return true; 
}
//查找第i个结点
LNode* ListSearchNode(LinkList L, int i)
{
	if (i < 1)	return NULL;
	int j = 1;//计数值
	LNode* p = L->next;//p初始指向第一个结点
	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}
	return p;	//返回第i个结点，若i大于表长，返回NULL
}
//按值查找结点
LNode* ListSearchElem(LinkList L, ElemType e)
{
	LNode* p = L->next;
	while (p != NULL && p->data != e) {
		p = p->next;
	}
	return p;
}
//求链表表长（头结点不算长度）
int ListLenth(LinkList L)
{
	int len = 0;
	if (L == NULL)	return 0;
	else len++;

	LNode* p = L->next;//p初始指向第一个结点
	if (p == NULL)	return 0;
	while (p->next != NULL) {
		p = p->next;
		len++;
	}
	return len;
}
//第i个位置后插结点e，新结点位于i处
bool ListRearInsert(LinkList& L, int i, ElemType e)
{
	LNode* p = ListSearchNode(L, i - 1);//找到第i-1个结点
	if (p == NULL)	return false;

	LNode* s = new LNode;
	if (s == NULL)	return false;
	s->data = e;
	s->next = p->next;
	p->next = s;		//p后插入结点
	return true;
}
//第i个位置前插结点e，新结点位于i-1处
bool ListFrontInsert(LinkList& L, int i, ElemType e)
{
	LNode* p = ListSearchNode(L, i - 1);//找到第i-1个结点
	if (p == NULL)	return false;
	
	LNode* s = new LNode;
	if (s == NULL)	return false;
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;		//实际上是后插结点，只不过数据域交换了
	return true;
}
//删除第i个结点，并返回删除数据
bool ListDeleteNode(LinkList& L, int i, ElemType& e)
{
	LNode* p = ListSearchNode(L, i - 1);//找到第i-1个结点
	if (p == NULL)	return false;

	LNode* q = p->next;	//q指向待删除结点
	if (q == NULL)	return false;
	p->next = q->next;
	e = q->data;
	free(q);	//删除结点，返回删除数据
	q = NULL;
	return true;
}
//删除特定结点e
bool ListDeleltNodeP(LinkList& L, ElemType e)
{
	LNode* p = ListSearchElem(L, e);//找到要删除的p结点
	if (p == NULL)	return false;

	LNode* q = p->next;//q指向待删除结点的后一个结点
	if (q == NULL) {	//q为NULL，表示p为链表最后一个结点
		//要找到p的前一个结点，才能删除p；单链表只能从头开始找，时间复杂度较高
		LNode* t = L;
		while (t->next != p) {
			t = t->next;
		}
		//此时t为p的前一个结点
		t->next = NULL;
		free(p);
		p = NULL;	//删除p结点
	}
	else {
		p->next = q->next;
		p->data = q->data;	//覆盖p的数据域，相当于删除p
		free(q);
		q = NULL;
	}
	return true;
}
//从头输出单链表
void ListPrint(LinkList L)
{
	if (L == NULL || L->next == NULL)	return;
	
	LNode* p = L->next;
	int i = 1;
	while (p != NULL) {
		std::cout << "data[" << i << "]:" << p->data << "     ";
		p = p->next;	//必须先输出再移动指针
		i++;
	}
	std::cout << std::endl;
}


int main()
{
	LinkList L;
	/********************单链表的建立、销毁以及求表长*********************/
	//头插法建立单链表
	std::cout << "请输入数据建立单链表，输入9999表示结束：\n";
	if (ListHeadInit(L)) {
		std::cout << "头插法建立单链表成功！单链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "头插法建立单链表失败！\n";
	}
	//销毁单链表
	if (ListDestory(L)) {
		std::cout << "原单链表销毁成功！\n";
		ListPrint(L);
	}
	else {
		std::cout << "原单链表销毁失败！\n";
	}
	//尾插法建立单链表
	std::cout << "请输入数据建立单链表，输入9999表示结束：\n";
	if (ListTailInit(L)) {
		std::cout << "尾插法建立单链表成功！单链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "尾插法建立单链表失败！\n";
	}
	std::cout << "单链表长度：" << ListLenth(L) << std::endl;
	/******************************************************************/


	/********************单链表的插入与删除（成功）**********************/
	std::cout << "\n\n\n";
	if (ListRearInsert(L, 4, 12345)) {	//第4个位置后插元素12345
		std::cout << "第4个位置后插12345成功！新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "第4个位置后插12345失败！\n";
	}
	if (ListFrontInsert(L, 2, 999)) {	//第2个位置前插元素999
		std::cout << "第2个位置前插999成功！新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "第2个位置前插12345失败！\n";
	}
	int e;
	if (ListDeleteNode(L, 3, e)) {	//删除第3个位置的元素
		std::cout << "删除第3个位置元素成功！删除元素为：" << e << "新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "删除第3个位置元素失败！\n";
	}
	if (ListDeleltNodeP(L, 12345)) {	//删除12345元素
		std::cout << "删除12345成功！新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "删除12345失败！\n";
	}
	/******************************************************************/


	/********************单链表的插入与删除（失败）**********************/
	std::cout << "\n\n\n";
	if (ListRearInsert(L, 10, 12345)) {	//第10个位置后插元素12345
		std::cout << "第10个位置后插12345成功！新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "第10个位置后插12345失败！\n";
	}
	if (ListFrontInsert(L, 15, 999)) {	//第15个位置前插元素999
		std::cout << "第15个位置前插999成功！新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "第15个位置前插12345失败！\n";
	}
	int temp;
	if (ListDeleteNode(L, 9, temp)) {	//删除第9个位置的元素
		std::cout << "删除第9个位置元素成功！删除元素为：" << temp << "新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "删除第9个位置元素失败！\n";
	}
	if (ListDeleltNodeP(L, 12345)) {	//删除12345元素
		std::cout << "删除12345成功！新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "删除12345失败！\n";
	}
	/******************************************************************/

	system("pause");
	return 0;
}

不带头结点代码实现（C）：

#include <stdio.h>
#include <stdlib.h>

typedef int ElemType;
typedef struct LNode {	//单链表结点
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;

//此处讨论为不带头结点的单链表，声明头指针变量的时候要赋值为NULL
//尾插法建立单链表，所得到的单链表为顺序
//LinkList* L 等价于 LNode** L，因为要修改指针本身，所以要用到指针的指针
int ListTailInit(LinkList* L)
{
	int x;
	//这里传入的是二级指针，(*L)就是链表的头指针
	LNode* r = (*L);	//尾指针
	scanf_s("%d", &x);
	while (x != 9999) {	//手动输入数据，建立单链表
		LNode* s = (LNode*)malloc(sizeof(LNode));
		if (s == NULL)	return 0;
		s->data = x;
		if ((*L) == NULL) {	//当前为空表
			*L = s;
			r = s;		//头指针和尾指针同时指向第一个结点
		}
		else {
			r->next = s;
			r = s;
		}
		scanf_s("%d", &x);	//输入新元素
	}
	r->next = NULL;	//防止脏数据遗留
	return 1;
}
//头插法建立单链表，所得到的单链表为逆序，可用于链表的逆置
int ListHeadInit(LinkList* L)
{
	int x;
	//这里传入的是二级指针，(*L)就是链表的头指针
	scanf_s("%d", &x);
	while (x != 9999) {	//手动输入数据，建立单链表
		LNode* s = (LNode*)malloc(sizeof(LNode));
		if (s == NULL)	return 0;
		s->data = x;
		s->next = NULL;
		if ((*L) == NULL) {	//当前为空表
			*L = s;
		}
		else {
			s->next = *L;
			*L = s;		//从链头处插入
		}
		scanf_s("%d", &x);
	}
	return 1;
}
//销毁单链表
int ListDestory(LinkList* L)
{
	LNode* p = *L;//p指向待删除结点
	while (p != NULL) {
		*L = (*L)->next;
		free(p);
		p = *L;
	}
	return 1;
}
//查找第i个结点
LNode* ListSearchNode(LinkList L, int i)
{
	if (i < 1)	return NULL;

	int j = 1;//计数值
	LNode* p = L;//p初始指向第一个结点
	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}
	return p;	//返回第i个结点，若i大于表长，返回NULL
}
//按值查找结点
LNode* ListSearchElem(LinkList L, ElemType e)
{
	if (L == NULL)	return NULL;

	LNode* p = L;//p初始指向第一个结点
	while (p != NULL && p->data != e) {
		p = p->next;
	}
	return p;
}
//求链表表长（头结点不算长度）
int ListLenth(LinkList L)
{
	if (L == NULL)	return 0;

	LNode* p = L;//p初始指向第一个结点
	int len = 1;
	while (p->next != NULL) {
		p = p->next;
		len++;
	}
	return len;
}
//第i个位置后插结点e，新结点位于i处
int ListRearInsert(LinkList* L, int i, ElemType e)
{
	LNode* p = ListSearchNode(*L, i - 1);//找到第i-1个结点
	if (p == NULL)	return 0;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL)	return 0;
	s->data = e;
	s->next = p->next;
	p->next = s;		//p后插入结点
	return 1;
}
//第i个位置前插结点e，新结点位于i-1处
int ListFrontInsert(LinkList* L, int i, ElemType e)
{
	LNode* p = ListSearchNode(*L, i - 1);//找到第i-1个结点
	if (p == NULL)	return 0;

	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL)	return 0;
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;		//实际上是后插结点，只不过数据域交换了
	return 1;
}
//删除第i个结点，并返回删除数据
int ListDeleteNode(LinkList* L, int i, ElemType* e)
{
	LNode* p = ListSearchNode(*L, i - 1);//找到第i-1个结点
	if (p == NULL)	return 0;

	LNode* q = p->next;
	if (q == NULL)	return 0;
	p->next = q->next;
	*e = q->data;
	free(q);	//删除结点，返回删除数据
	q = NULL;
	return 1;
}
//删除特定结点e
int ListDeleltNodeP(LinkList* L, ElemType e)
{
	LNode* p = ListSearchElem(*L, e);//找到要删除的p结点
	if (p == NULL)	return 0;

	LNode* q = p->next;//q指向待删除结点的后一个结点
	if (q == NULL) {	//q为NULL，表示p为链表最后一个结点
		//要找到p的前一个结点，才能删除p；单链表只能从头开始找，时间复杂度较高
		LNode* t = *L;
		while (t->next != p) {
			t = t->next;
		}
		//此时t为p的前一个结点
		t->next = NULL;
		free(p);
		p = NULL;	//删除p结点
	}
	else {
		p->next = q->next;
		p->data = q->data;	//覆盖p的数据域，相当于删除p
		free(q);
		q = NULL;
	}
	return 1;
}
//从头输出单链表
void ListPrint(LinkList L)
{
	if (L == NULL)	return;

	LNode* p = L;
	int i = 1;
	while (p != NULL) {
		printf("data[%d]:%d     ", i, p->data);
		p = p->next;	//必须先输出再移动指针
		i++;
	}
	printf("\n");
}

int main()
{
	LinkList L = NULL;
	/********************单链表的建立、销毁以及求表长*********************/
	//头插法建立单链表
	printf("请输入数据建立单链表，输入9999表示结束：\n");
	if (ListHeadInit(&L)) {
		printf("头插法建立单链表成功！单链表为：\n");
		ListPrint(L);
	}
	else {
		printf("头插法建立单链表失败！\n");
	}
	//销毁单链表
	if (ListDestory(&L)) {
		printf("原单链表销毁成功！\n");
		ListPrint(L);
	}
	else {
		printf("原单链表销毁失败！\n");
	}
	//尾插法建立单链表
	printf("请输入数据建立单链表，输入9999表示结束：\n");
	if (ListTailInit(&L)) {
		printf("尾插法建立单链表成功！单链表为：\n");
		ListPrint(L);
	}
	else {
		printf("尾插法建立单链表失败！\n");
	}
	printf("单链表长度：%d\n", ListLenth(L));
	/******************************************************************/


	/********************单链表的插入与删除（成功）**********************/
	printf("\n\n\n");
	if (ListRearInsert(&L, 4, 12345)) {	//第4个位置后插元素12345
		printf("第4个位置后插12345成功！新链表为：\n");
		ListPrint(L);
	}
	else {
		printf("第4个位置后插12345失败！\n");
	}
	if (ListFrontInsert(&L, 2, 999)) {	//第2个位置前插元素999
		printf("第2个位置前插999成功！新链表为：\n");
		ListPrint(L);
	}
	else {
		printf("第2个位置前插12345失败！\n");
	}
	int e;
	if (ListDeleteNode(&L, 3, &e)) {	//删除第3个位置的元素
		printf("删除第3个位置元素成功！删除元素为：%d新链表为：\n", e);
		ListPrint(L);
	}
	else {
		printf("删除第3个位置元素失败！\n");
	}
	if (ListDeleltNodeP(&L, 12345)) {	//删除12345元素
		printf("删除12345成功！新链表为：\n");
		ListPrint(L);
	}
	else {
		printf("删除12345失败！\n");
	}
	/******************************************************************/


	/********************单链表的插入与删除（失败）**********************/
	printf("\n\n\n");
	if (ListRearInsert(&L, 10, 12345)) {	//第10个位置后插元素12345
		printf("第10个位置后插12345成功！新链表为：\n");
		ListPrint(L);
	}
	else {
		printf("第10个位置后插12345失败！\n");
	}
	if (ListFrontInsert(&L, 15, 999)) {	//第15个位置前插元素999
		printf("第15个位置前插999成功！新链表为：\n");
		ListPrint(L);
	}
	else {
		printf("第15个位置前插12345失败！\n");
	}
	int temp;
	if (ListDeleteNode(&L, 9, &temp)) {	//删除第9个位置的元素
		printf("删除第9个位置元素成功！删除元素为：%d新链表为：\n", temp);
		ListPrint(L);
	}
	else {
		printf("删除第9个位置元素失败！\n");
	}
	if (ListDeleltNodeP(&L, 12345)) {	//删除12345元素
		printf("删除12345成功！新链表为：\n");
		ListPrint(L);
	}
	else {
		printf("删除12345失败！\n");
	}
	/******************************************************************/

	system("pause");
	return 0;
}

不带头结点代码实现（C++）：

#include <iostream>

typedef int ElemType;
typedef struct LNode {	//单链表结点
	ElemType data;
	struct LNode* next;
}LNode, * LinkList;

//此处讨论为不带头结点的单链表，声明头指针变量的时候要赋值为NULL
//尾插法建立单链表，所得到的单链表为顺序
bool ListTailInit(LinkList& L)
{
	int x;
	LNode* r = L;//尾指针
	std::cin >> x;
	while (x != 9999) {
		LNode* s = new LNode;
		if (s == NULL)	return false;
		s->data = x;
		s->next = NULL;
		if (L == NULL) {	//当前为空表
			L = s;
			r = s;		//头指针和尾指针同时指向第一个结点
		}
		else {
			r->next = s;
			r = s;
		}
		std::cin >> x;	//输入新元素
	}
    r->next = NULL;	//防止脏数据遗留
	return true;
}
//头插法建立单链表，所得到的单链表为逆序，可用于链表的逆置
bool ListHeadInit(LinkList& L)
{
	int x;
	std::cin >> x;
	while (x != 9999) {
		LNode* s = new LNode;
		s->data = x;
		s->next = NULL;
		if (L == NULL) {	//当前为空表
			L = s;
		}
		else {
			s->next = L;
			L = s;		//从链头处插入
		}
		std::cin >> x;
	}
	return true;
}
//销毁单链表
bool ListDestory(LinkList& L)
{
	LNode* p = L;//p指向待删除结点
	while (p != NULL) {
		L = L->next;
		free(p);
		p = L;
	}
	return true;
}
//查找第i个结点
LNode* ListSearchNode(LinkList L, int i)
{
	if (i < 1 || L == NULL)	return NULL;

	LNode* p = L;
	int j = 1;	//计数值
	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}
	return p;
}
//按值查找结点
LNode* ListSearchElem(LinkList L, ElemType e)
{
	if (L == NULL)	return NULL;

	LNode* p = L;
	while (p != NULL && p->data != e) {
		p = p->next;
	}
	return p;
}
//求链表表长（头结点不算长度）
int ListLenth(LinkList L)
{
	if (L == NULL)	return 0;

	LNode* p = L;//p指向第一个结点
	int len = 1;
	while (p->next != NULL) {
		p = p->next;
		len++;
	}
	return len;
}
//第i个位置后插结点e，新结点位于i处
bool ListRearInsert(LinkList& L, int i, ElemType e)
{
	LNode* p = ListSearchNode(L, i - 1);//查找到第i-1个结点
	if (p == NULL)	return false;

	LNode* s = new LNode;
	s->data = e;
	s->next = p->next;
	p->next = s;		//p后插入结点
	return true;
}
//第i个位置前插结点e，新结点位于i-1处
bool ListFrontInsert(LinkList& L, int i, ElemType e)
{
	LNode* p = ListSearchNode(L, i - 1);//查找到第i-1个结点
	if (p == NULL)	return false;

	LNode* s = new LNode;
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;		//实际上是后插结点，只不过数据域交换了
	return true;
}
//删除第i个结点，并返回删除数据
bool ListDeleteNode(LinkList& L, int i, ElemType& e)
{
	LNode* p = ListSearchNode(L, i - 1);//查找到第i-1个结点
	if (p == NULL)	return false;

	LNode* q = p->next;	//q指向待删除结点
	if (q == NULL)	return false;
	p->next = q->next;
	e = q->data;
	free(q);	//删除结点，返回删除数据
	q = NULL;
	return true;
}
//删除特定结点e
bool ListDeleltNodeP(LinkList& L, ElemType e)
{
	LNode* p = ListSearchElem(L, e);//找到要删除的p结点
	if (p == NULL)	return false;

	LNode* q = p->next;
	if (q == NULL) {	//q为NULL，表示p为链表最后一个结点
		//要找到p的前一个结点，才能删除p；单链表只能从头开始找，时间复杂度较高
		LNode* t = L;
		while (t->next != p) {
			t = t->next;
		}
		//此时t为p的前一个结点
		t->next = NULL;
		free(p);
		p = NULL;//删除p结点
	}
	else {
		p->next = q->next;
		p->data = q->data;	//覆盖p的数据域，相当于删除p
		free(q);
		q = NULL;
	}
	return true;
}
//从头输出单链表
void ListPrint(LinkList L)
{
	if (L == NULL)	return;

	LNode* p = L;
	int i = 1;
	while (p != NULL) {
		std::cout << "data[" << i << "]:" << p->data << "     ";
		p = p->next;	//必须先输出再移动指针
		i++;
	}
	std::cout << std::endl;
}


int main()
{
	LinkList L = NULL;
	/********************单链表的建立、销毁以及求表长*********************/
	//头插法建立单链表
	std::cout << "请输入数据建立单链表，输入9999表示结束：\n";
	if (ListHeadInit(L)) {
		std::cout << "头插法建立单链表成功！单链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "头插法建立单链表失败！\n";
	}
	//销毁单链表
	if (ListDestory(L)) {
		std::cout << "原单链表销毁成功！\n";
		ListPrint(L);
	}
	else {
		std::cout << "原单链表销毁失败！\n";
	}
	//尾插法建立单链表
	std::cout << "请输入数据建立单链表，输入9999表示结束：\n";
	if (ListTailInit(L)) {
		std::cout << "尾插法建立单链表成功！单链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "尾插法建立单链表失败！\n";
	}
	std::cout << "单链表长度：" << ListLenth(L) << std::endl;
	/******************************************************************/


	/********************单链表的插入与删除（成功）**********************/
	std::cout << "\n\n\n";
	if (ListRearInsert(L, 4, 12345)) {	//第4个位置后插元素12345
		std::cout << "第4个位置后插12345成功！新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "第4个位置后插12345失败！\n";
	}
	if (ListFrontInsert(L, 2, 999)) {	//第2个位置前插元素999
		std::cout << "第2个位置前插999成功！新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "第2个位置前插12345失败！\n";
	}
	int e;
	if (ListDeleteNode(L, 3, e)) {	//删除第3个位置的元素
		std::cout << "删除第3个位置元素成功！删除元素为：" << e << "新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "删除第3个位置元素失败！\n";
	}
	if (ListDeleltNodeP(L, 12345)) {	//删除12345元素
		std::cout << "删除12345成功！新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "删除12345失败！\n";
	}
	/******************************************************************/


	/********************单链表的插入与删除（失败）**********************/
	std::cout << "\n\n\n";
	if (ListRearInsert(L, 10, 12345)) {	//第10个位置后插元素12345
		std::cout << "第10个位置后插12345成功！新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "第10个位置后插12345失败！\n";
	}
	if (ListFrontInsert(L, 15, 999)) {	//第15个位置前插元素999
		std::cout << "第15个位置前插999成功！新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "第15个位置前插12345失败！\n";
	}
	int temp;
	if (ListDeleteNode(L, 9, temp)) {	//删除第9个位置的元素
		std::cout << "删除第9个位置元素成功！删除元素为：" << temp << "新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "删除第9个位置元素失败！\n";
	}
	if (ListDeleltNodeP(L, 12345)) {	//删除12345元素
		std::cout << "删除12345成功！新链表为：\n";
		ListPrint(L);
	}
	else {
		std::cout << "删除12345失败！\n";
	}
	/******************************************************************/

	system("pause");
	return 0;
}

测试结果：

总结：

采用C++的引用在修改指针的时候更方便，C中要修改指针的话就要用到指针的指针->二级指针。

以上

以上均为个人学习心得，如有错误，请不吝赐教~

THE END

~O'Connor
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构与算法实验（C++）：单链表实验-代码
01-18
1.内容概要： （1）实验目的： 1）熟练掌握单链表的存储特点； 2）熟练掌握单链表的基本操作算法； 3）熟练掌握面向对象程序设计方法； 4）能灵活使用单链表解决具体的问题。...数据结构与算法实验
数据结构01：单链表（C/C++语言）
ALAN_CF的博客
01-20 814
数据结构01：单链表（C/C++语言））初始化单链表使用C语言结构体描述该单链表的基础结构初始化一个带头结点的单链表计算从某个结点p开始直到链表末尾的结点总数（包括此结点p）从某个结点P开始，打印N个结点的数据（如果只剩余M个，不够N个，则打印到末尾，即打印M个）单链表插入在指定节点p之后插入指定数据元素在指定节点p之后插入指定节点s在指定的链表的索引位置插入指定的数据元素（带头结点链表）在指定的链表结点p之前插入指定的新元素在指定的链表结点p之前插入指定的新结点s单链表删除删除结点P后面链接的第一个结点（
数据结构-单链表(c++实现)
qq_41884952的博客
03-07 213
顺序表用一段地址连续的存储单元存储数据元素，最大的缺点就是插入和删除时需要移动大量元素，耗费时间。链式存储线性表时，存储单元可以是连续的也可以是不连续的，通过“链”建立起数据元素之间的逻辑关系，因此插入和删除元素操作不需要移动元素，而只需要修改指针，但也会失去顺序表可随机存取的优点。我们将存储数据元素的域称为数据域，把存储后继位置的域称为指针域，这两部分信息组成结点。而此链表每个结点只含有一个指针域，所以叫做单链表。以上为单链表的创建等一系列操作，本人小白，如有错误，欢迎大佬们指点出来。
单链表c/c++ 数据结构
?_#的博客
09-12 242
  #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; /* struct node{}; node */ typedef struct node{ int data; struct node *next; }ListNode,*LinkList; //头插法建立单链表 LinkList CreateListOnHead(){ i...
(C语言 C++) 数据结构：单链表的实现
m0_67839004的博客
03-19 55
【代码】(C语言 C++) 数据结构：单链表的实现。
数据结构：利用单链表实现大数运算（C++）
xiaosuqi1778的博客
10-06 763
利用单链表实现大数的+、-、*和阶乘（选做）
数据结构单链表初始化c/c++语言代码实现
01-22
很多刚接触数据结构的小白在学完单链表，只知道理论知识，却不知道如何实现，这是用c++语言实现的两种单链表初始化过程
单链表.rar_数据结构_C/C++_
08-10
使用c语言，用单链表完成学生管理系统，使用单链表完成对学生信息的读取、学生增删、指针交换实现姓名/学号/单科成绩的排序，由学生姓名或学号进行查询学生全部信息，实现学生数量无限制的链式结构，可对学生进行...
C++数据结构单链表实验：学生信息管理系统，源代码+实验报告.zip
11-14
对学生信息的单链表已经实现以下操作： //初始化 Status InitList(LinkList& L);...包含实验目的，实验分析，实验源程序，实验结果，适合数据结构中单链表的作业提交和学习，注释较多，适合基础人群学习。
LinkList.zip_数据结构_C/C++_
08-11
单链表的创建，节点的插入，节点的删除，清空链表，销毁链表等等
【数据结构】二叉树（带图详解）
Z1tai的博客
04-27 1546
链表和数组都是线性结构，而树是非线性的结构。树是依靠分支关系定义出的一种层次结构。社会亲缘关系和组织结构图都可以用树来形象地表示。
数据结构系列-二叉树之前序遍历
in_seattle的博客
04-26 509
这篇文章，我们主要的内容是对二叉树当中的前历的算法进行讲解，二叉树中的算法所要求实现的是 从根到左子树再到右子树的遍历顺序，可能这样不太好理解，我们拿一张图片进行解释，我们先来分析一下这个的实现逻辑是什么，按照根节点，左子树，右子树的顺序，我们先来判断一下这个应该实现的结果是什么。在这里，我们将空也表现了出来，那下面，我们就讲解一下怎么用代码实现这个过程。假设在这个二叉树当中，我们要实现二叉树遍历当中的前历，我们应该怎么做呢。这些代码我们在前面就详细的进行了展开，在这里我们就不进行详细的讲解。
【数据结构】第二章 线性数据结构.线性表.顺序表
KX_52517的博客
04-26 1350
线性数据结构章节
【数据结构】图（Graph）
2201_75475240的博客
04-24 1305
本文章介绍数据结构中的图的基本知识，包括概念、邻接表、邻接矩阵、深度遍历和广度遍历，且还包含408习题（附有解析）。此外，含有关于邻接表和两种遍历全部具体实现代码。
数据结构练习：链表扩容
2301_80369371的博客
04-25 340
一：创建一个新链表，遍历原链表的同时，将原链表的值复制给新链表。二：将新链表插入到原链表中（大致如下）3.*&是c++的写法，等同于c中的*2.记得malloc后要free。1.头结点是不存有数据的。
数据结构(八)——排序
señoritaw的博客
04-25 1175
排序(Sort)，就是重新排列表中的元素，使表少的元素满足按关键字有序的过程。输入∶n个记录R1,R2...., Rn，对应的关键字为k1, k2,... , kn输出:输入序列的一个重排R1',R2'....,Rn'，使得有k1'≤k2'≤...≤kn'(也可递减)算法的稳定性。若待排序表中有两个元素R,和R，其对应的关键字相同即key = keyj，且在排序前R;在R,的前面，若使用某一排序算法排序后，R仍然在R的前面，则称这个排序算法是稳定的，否则称排序算法是不稳定的。
排序-八大排序FollowUp
最新发布
2301_78838401的博客
04-27 984
最坏情况下:0(n^2)最好情况下:0(n)当数据越有序 排序越快适用于: 待排序序列 已经基本上趋于有序了!空间复杂度:0(1)稳定性:稳定的。
【C 数据结构】二叉树
普罗米修斯的博客
04-24 1138
性质 3 的计算方法为：对于一个二叉树来说，除了度为 0 的叶子结点和度为 2 的结点，剩下的就是度为 1 的结点（设为。同时，对于每一个结点来说都是由其父结点分支表示的，假设树中分枝数为 B，那么总结点数。例如，图 1a) 就是一棵二叉树，而图 1b) 则不是。而分枝数是可以通过 n1 和 n2 表示的，即。两种方式得到的 n 值组成一个方程组，就可以得出。所以，n 用另外一种方式表示为。使用顺序表（数组）存储二叉树。顺序存储只适用于完全二叉树。满二叉树也是完全二叉树。每个结点的度都为 2。
数据结构系列-堆排序当中的T-TOK问题
in_seattle的博客
04-24 400
在这个代码当中有几个比较厉害的点需要我们注意一下，首先在他的创建数据的那个阶段，我们使用了随机数，但是它那里进行了取余，这样的好处是将数字的范围控制在一个程度之内，可以检测自己的程序是否正确表达。T-TOK说简单点，就是说，假如有10000个数据（随机的），让你找到其中最大的10个数据，有什么快速的方法，遍历吗？这个是不显示的，效率是最低的。之前我们讲到了堆排序的实现逻辑，那么接下来我们重点关注的就是其中的T-TOK问题。所以，我们能想到的比较好的方法就是堆排序当中的T-TOK问题。
数据结构单链表c++
08-24
单链表是一种常见的数据结构，用于存储一系列的节点连接起来的数据。 在C语言中，我们可以使用结构体来定义一个节点，包含一个数据域和一个指向下一个节点的指针域。代码如下： ```c struct Node { int data; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值