基础数据结构3：单链表

1.单链表

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,int val);

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

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

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

//按照数值删除 遇到值为val的第一个有效节点，删除并且释放其内存
bool Del_val(PNode plist, int val);

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

//寻找数值为val的前驱
Node* Get_prior(PNode plist, int val);

//寻找数值为val的节点的后继
Node* Get_next(PNode plist, int 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<stdlib.h>
#include<malloc.h>
#include"list(7_17).h"

//for (p = plist; p->next != NULL; p = p->next);需要前驱，经常用于插入的删除等操作
//for (p = p->next; p != NULL; p = p->next);不需要前驱，经常用于打印，查找操作

//初始化
void Init_list(Node* plist)//Node*==PNode
{
	assert(plist != NULL);
	if (plist == NULL) return;
	plist->next = NULL;
}

//头插
bool Insert_head(PNode plist, int val)
{
	assert(plist != NULL);
	//申请新节点
	Node* pnewnode = (Node*)malloc(sizeof(Node) * 1);
	assert(pnewnode != NULL);
	pnewnode->data = val;
	//不需要重新初始化pnewnode->next，接下来会对其重新赋值
	
	//直接插入
	pnewnode->next = plist->next;
	plist->next = pnewnode;
	return true;
}

//尾插
bool Insert_tail(PNode plist, int val)
{
	assert(plist != NULL);
	//创建新节点
	Node* pnewnode= (Node*)malloc(sizeof(Node*));
	assert(pnewnode != NULL);
	pnewnode->data = val;
	//找到合适插入位置
	Node* p = plist;
	for (p = plist; p->next != NULL; p = p->next);//循环结束后，p指向最后一个节点
	//插入数值
	pnewnode->next = p->next;
	p->next = pnewnode;
	return true;
}

//按照位置插入 pos
bool Insert_pos(PNode plist, int pos, int val)
{
	assert(plist != NULL);
	//创建新节点
	Node* pnewnode = (Node*)malloc(sizeof(Node) * 1);
	assert(pnewnode != NULL);
	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 != NULL && pos >= 0 && pos < Get_length(plist));
	if (pos > 0 || pos >= Get_length(plist)) return false;
	//找到删除节点的上一个节点
	Node* p = plist;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}
	//删除节点
	Node* q = p->next;//申请指针，指向要删除的节点
	p->next = q->next;//让删除节点的上个节点的next指向删除节点的下一个节点
	free(q);//释放删除的节点
	
	return true;
}

//按照数值删除 遇到值为val的第一个有效节点，删除并且释放其内存
bool Del_val(PNode plist, int val)
{
	assert(plist != NULL);
	Node* p = Get_prior(plist, val);
	if (p == NULL)
	{
		return false;
	}
	Node* q = p->next;
	p->next = q->next;
	free(q);
}

//查找search 查找数值为val的第一个节点，返回其地址
struct Node* Search(PNode plist, int val)
{
	assert(plist != NULL);
	//遍历单链表，寻找数值为val的节点，将其返回
	for (Node* p = plist->next; p != NULL; p = p->next)
	{
		if (p->data == val)
		{
			return p;
		}
	}
	return NULL;
}

//寻找数值为val的前驱
Node* Get_prior(PNode plist, int val)
{
	assert(plist != NULL);
	Node* p = plist;
	for (p; p->next != NULL; p = p->next)
	{
		if (p->next->data == val)
		{
			return p;
		}
	}
	return NULL;
}

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

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


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

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

//清空(与销毁一致）
void Clear(PNode plist)
{
	Destroy(plist);
}

//销毁
void Destroy(PNode plist)//一值头删
{
	assert(plist != NULL);
	while (plist->next != NULL)//每次都判断第一个有效节点是否存在
	{
		Node* p = plist->next;
		plist->next = p->next;
		free(p);
	}
	//plist->next = NULL;此时无有效节点
}
void Destroy2(PNode plist)//较难  
{
	assert(plist != NULL && plist->next != NULL);
	Node* p = plist->next;
	Node* q = p->next;
	plist->next = NULL;

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

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

main.cpp
//7_20
//单链表的实现 
#include<stdio.h>
#include"list(7_17).h"

int main()
{
	struct Node ls;
	Init_list(&ls);

	for (int i = 0; i < 10; i++)
	{
		Insert_pos(&ls, i, i + 1);
	}
	Show(&ls);
	printf("length=%d\n", Get_length(&ls));

	Insert_head(&ls, 100);
	Insert_tail(&ls, 200);
	Show(&ls);
	printf("length=%d\n", Get_length(&ls));

	Del_pos(&ls, 2);
	Show(&ls);


	Del_val(&ls, 7);
	Show(&ls);
	printf("length=%d\n", Get_length(&ls));

	return 0;
}

2.3.单链表
（1）逻辑相邻，物理上不一定相邻
（2）随机访问数据的时间复杂度O(n)
（3）插入数据的时间复杂度O(1)，不需要挪动数据
尾插时时间复杂度为（1）
（4）删除数据时间复杂度O（1），不需要挪动数据
尾删时时间复杂度为O（1）
（5）查找search书简复杂度O(n)
经常访问节点，不经常插入和删除节点，选择顺序表
经常插入和删除节点，不经常访问节点，选择单链表
单链表两种实现方式：
（1）带头节点，实现简单，理解简单
（2）不带头结点，头指针会出现二级指针，因此较难且不好理解
通过子函数去影响父函数，必须有取地址操作并且还得有解引用操作（取地址和解引用，缺一不可）。