基础数据结构--线性表——单链表

单链表和顺序表的区别

顺序表：逻辑相邻，物理相邻 简单

• 随机访问时间复杂度O(1)
• 插入时间复杂度O(n) 尾插的时间复杂度O(1)
• 删除时间复杂度O(n) 尾删的时间复杂度O(1)
• 查找Search时间复杂度O(n)

单链表：逻辑相邻，物理不一定相邻

• 随机访问时间复杂度O(n)
• 插入的时间复杂度O(1) 不需要挪动数据
• 删除的时间复杂度O(1) 不需要挪动数据
• 查找Search时间复杂度O(n)
  如果我经常访问节点，不经常插入和删除节点，我选哪一种？
  选顺序表
  如果我经常插入和删除节点，不经常访问节点，我选哪一种？
  选单链表

程序清单

先命名单链表为list

list.h

#pragma once 

typedef int ElemType;

typedef struct Node
{
	ElemType data;//数据域  保存其数据本身
	struct Node* next;//指针域  指向下一个数据节点的地址
}Node, *PNode;

//增删改查

//初始化
void Init_List(Node * plist);//Node * == PNode

//头插
bool Insert_Head(PNode plist, ElemType val);

//尾插
bool Insert_Tail(PNode plist, ElemType val);

//按位置插入  pos  
bool Insert_Pos(PNode plist, int pos, ElemType val);

//按位置删除 pos 
bool Del_Pos(PNode plist, int pos);

//按值删除 遇到值为val的第一个有效节点 删除掉 释放其内存
bool Del_Val(PNode plist, ElemType val);

//查找search 查找值我val的第一个节点，返回其地址
struct Node* Search(PNode plist, ElemType val);

//寻找值为val的节点的前驱
Node* Get_Prior(PNode plist, ElemType val);

//寻找值为val的节点的后继
Node* Get_Next(PNode plist, ElemType val);

//判空
bool IsEmpty(PNode plist);

//判满
//bool IsFull(PNode plist);

//获取其有效值长度
int Get_length(PNode plist);

//清空
void Clear(PNode plist);

//销毁
void Destroy(PNode plist);
void Destroy2(PNode plist);
//打印
void Show(PNode plist);

list.cpp

#include <stdio.h>
#include <assert.h>
#include<stdbool.h>
#include <stdlib.h>
#include "list.h"

//初始化
void Init_List(Node* plist)//Node * == PNode
{
	assert(plist != nullptr);
	if(plist == nullptr)
		return;

	//plist->data; 不需要初始化， 因为没有使用，直接浪费掉了
	plist->next = nullptr;
}

//头插
bool Insert_Head(PNode plist, ElemType val)
{
	assert(plist != nullptr);

	//申请新节点
	Node* pnewnode = (Node*)malloc(sizeof(Node) * 1);
	assert(pnewnode != nullptr);
	pnewnode->data = val;
	//pnewnode->next = nullptr; 这里不需要初始化， 因为接下来就会对其重新赋值

	//直接插入 1 2 顺序不能反
	pnewnode->next = plist->next;//1
	plist->next = pnewnode;//2

	return true;
}

//尾插
bool Insert_Tail(PNode plist, ElemType val)
{
	assert(plist != nullptr);

	//1.创建新节点
	Node* pnewnode = (Node*)malloc(sizeof(Node) * 1);
	assert(pnewnode != nullptr);
	pnewnode->data = val;

	//2.找到合适的插入位置
	Node* p = plist;
	for (p = plist; p->next != NULL; p = p->next);//让for循环跑完   p刚好指向最后一个有效节点

	//3.插入
	pnewnode->next = p->next;
	p->next = pnewnode;

	return true;
}

//按位置插入  pos  
bool Insert_Pos(PNode plist, int pos, ElemType val)
{
	assert(plist != nullptr);

	//创建新节点
	Node* pnewnode = (Node*)malloc(sizeof(Node) * 1);
	assert(pnewnode != nullptr);
	pnewnode->data = val;

	//找合适的插入位置 根据pos
	Node* p = plist;
	for(int i = 0; i < pos; ++i)
	{
		p = p->next;
	}
	//插入
	pnewnode->next = p->next;//让新节点的next赋值为之前上一个节点的next（保证后边的节点不丢失）
	p->next = pnewnode;//让前驱节点的next指向新节点

	return true;
}

//按位置删除 pos 
bool Del_Pos(PNode plist, int pos)
{
	assert(plist != nullptr && pos >= 0 && pos < Get_length(plist));
	if(pos < 0 || pos >= Get_length(plist))
	{
		return false;
	}

	//1.找到删除节点的上一个节点
	Node* p = plist;
	for(int i = 0; i < pos; ++i)
	{
		p = p->next;
	}

	//2.删除要删除的节点
	Node *q = p->next;//申请一个新指针  指向要删除的节点
	p->next = q->next;//p->next = p->next->next; //让删除节点的上一个节点的next指向删除节点的下一个节点
	free(q);//释放要删除的节点

	return true;

}

//按值删除 遇到值为val的第一个有效节点 删除掉 释放其内存
bool Del_Val(PNode plist, ElemType val)
{
	assert(plist != nullptr);

	Node* p = Get_prior(plist, val);
	if(p == nullptr)
	{
		return false;
	}

	Node *q = p->next;//申请一个新指针  指向要删除的节点
	p->next = q->next;//让删除节点的上一个节点的next指向删除节点的下一个节点
	free(q);//释放要删除的节点

	return true;
}

//查找search 查找值我val的第一个节点，返回其地址
struct Node* Search(PNode plist, ElemType val)
{
	assert(plist != nullptr);

	//遍历一遍单链表， 找值为val的节点，将其地址返回
	for(Node* p = plist->next; p != nullptr; p = p->next)
	{
		if(p->data == val)//判断当前节点的数据域 是否 为val 
		{
			return p;
		}
	}
	return nullptr;
}

//寻找值为val的节点的前驱
Node* Get_Prior(PNode plist, ElemType val)
{
	assert(plist != nullptr);

	Node* p = plist;
	for(p; p->next != nullptr; p = p->next)
	{
		if(p->next->data == val)
		{
			return p;
		}
	}
	return nullptr;
}

//寻找值为val的节点的后继
Node* Get_Next(PNode plist, ElemType val)
{
	Node* p = Search(plist, val);
	if(p == nullptr)
	{
		return nullptr;
	}
	return p->next;
}

//判空
bool IsEmpty(PNode plist)
{
	return plist->next == nullptr;
}

//判满
//bool IsFull(PNode plist); //单链表不存在判满操作

//获取其有效值长度
int Get_Length(PNode plist)
{
	int count = 0;
	for(Node* p = plist->next; p != nullptr; p = p->next)
	{
		count++;
	}

	return count;
}

//清空
//单链表的清空，和销毁实现方式一致  都是将malloc来的节点全部释放掉
void Clear(PNode plist)
{
	Destroy(plist);
}

//销毁
void Destroy(PNode plist)//一值头删
{
	assert(plist != nullptr);

	while(plist->next != nullptr)//每次判断第一个有效节点是否存在
	{
		Node* p = plist->next;
		plist->next = p->next;
		free(p);
	}
	
	plist->next = nullptr;//此时没有有效节点，那么将plist->next 置为NULL
}

void Destroy2(PNode plist)//难一点，可以尝试理解  
{
	assert(plist != nullptr && plist->next != nullptr);

	Node* p = plist->next;
	Node* q;
	plist->next = nullptr;

	while(p != nullptr)
	{
		q = p->next;
		free(p);
		p = q;
	}
}


//打印
void Show(PNode plist)
{
	for(Node* p = plist->next; p != nullptr; p = p->next)
	{
		printf("%d ", p->data);
	}
	printf("\n");
}

main.cpp示例

#include<stdio.h>
#include"list.h"

int main(void)
{
	//初始化
	struct Node list;
	Init_List(&list);
	for (int i = 0; i < 10; ++i)
	{
		Insert_Pos(&list, i, i + 1);
	}
	Show(&list);

	//插入测试
	Insert_Head(&list, 100);
	Insert_Tail(&list, 100);
	Show(&list);
	printf("Length = %d\n", Get_Length(&list));

	//删除测试
	Del_Pos(&list, 3);
	Del_Val(&list, 6);
	Show(&list);
	printf("Length = %d\n", Get_Length(&list));

	//销毁链表
	Clear(&list);
	Destroy(&list);
	printf("Length = %d\n", Get_Length(&list));

	return 0;
}

运行结果

总结

找合适的位置：
1 需要前驱，经常用于插入和删除操作等等

for (p = plist; p->next != nullptr; p = p->next);

2 不需要前驱，经常用于打印，查找操作

for (p = plist->next; p != nullptr; p = p->next);

插入操作 两行代码

1.pnewnode->next = p->next;
2.p->next = pnewnode;
//pnewnode是新节点名字 p是插入位置

删除操作 三行代码

 1.Node *q = p->next;
 2.p->next = q->next;
 3.free(q);
 //p指向删除节点的上一个节点， q指向删除节点

两种销毁方式都可以，但建议掌握第一种（一直头删），第二种偏难，能掌握就掌握，掌握不了就只记第一种即可。