线性表的链式存储---单向链表(TOPIC Two)

不积跬步无以至千里，不积小流无以成江海

一. 一些基本概念

（1）单链表：单链表属于线性数据结构，与上节所介绍的顺序表不同的是，顺序表是占用的是连续内存空间进行存储，所以在物理结构和逻辑结构上均为连续。但单链表为链式的存储结构不需要内存空间地址连续，所以逻辑上连续，但物理上并不连续(但也有极小的可能连续)，每个节点之间通过指针域索引进而找到下一个节点的地址。单链表最前方有一个不存放任何元素的的头结点，在定义结构体后可通过list->head进行访问。

//定义一个单向链表节点
typedef struct LINKNODE{
	void* data;		//用于接收任何类型的数据
	struct LinkNode* next;
}LinkNode, *LinkList;

//单向链表结构体
typedef struct LINKLIST{
	LinkNode* head;
	int listsize;
}LinkList;

（2）若要频繁进行插入与删除操作，则链表与顺序表相比更加高效，顺序表的插入与删除要移动其他元素，而链表只需修改指针的指向即可，链表的时间复杂度为O(1)，顺序表的时间复杂度为O(n)。

//链表的删除操作步骤
r = p -> next;
p -> next = r -> next;
free(r);

//链表的插入操作步骤
q -> next = p -> next;
p -> next = q;

二. 代码实现

1. 在第i个位置插入元素值为value

//单链表的初始化
LinkList* Init_LinkList(){
	LinkList* list = (LinkList*)malloc(sizeof(LinkList));
	list -> listsize = 0;
	list -> head = (LinkNode*)malloc(sizeof(LinkNode));
	list -> head -> data = NULL;
	list -> head -> next = NULL;
	return list;
}
//插入
void Insert_LinkList(LinkList* list, int i, void* data){
	//非法操作直接退出
	if(list == NULL){
		return;
	}
	if(data == NULL){
		return;
	}
	//给定的位置越界，就在尾部插入
	if(i < 0 || i > list -> listsize){
		i = list -> listsize;
	}
	LinkNode* new_linknode = (LinkNode*)malloc(sizeof(LinkNode));
	new_linknode -> data = data;
	new_linknode -> next = NULL;
	LinkNode* pCurrent = list -> head;
	for(int j = 0; j < i; j++){
		pCurrent = pCurrent -> next;
	}
	new_linknode -> next = pCurrent -> next;
	pCurrent -> next = new_linknode;
	list -> listsize++;
}

2. 查找链表是否有某个值value并删除它

int FindDel_ListList = (LinkList* list, void* value){
	//非法操作直接退出
	int i = 0;
	if(list == NULL){
		return i = -1;
	}
	if(data == NULL){
		return i = -1;
	}
	LinkNode* pCurrent = list -> head -> next;
	while(pCurrent != NULL){
		if(pCurrent -> data == data){
			return i;		//将value所在的位置i返回
			break;
		}
		i++;
		pCurrent = pCurrent -> next;
	}
	if(i == -1){
		cout << "不好意思没找到！" << endl;
	}
	//查找删除节点i的前一个节点
	LinkNode* pCurrent = list -> head;
	for(int j = 0; j < i; j++){
		pCurrent = pCurrent -> next;
	}
	LinkNode* pFindDel = pCurrent -> next;
	pCurrent -> next = pFindDel -> next;
	free(pFindDel);
	list -> listsize--;
}

3. 从后到前打印一个链表的每个节点

思路： 从后到前打印链表，并且要求打印的过程中不能够修改链表的顺序(只读操作)，故可使用栈操作来实现，每经过一个节点就先使其入栈，直到遍历完整个链表后，再从栈顶取值打印。

#define _CRT_SECURE_NO_WARNINGS
using namespace std;
void PrintListReversingly_Iteratively(ListNode* pHead){
	std::stack<ListNode*>nodes;
	ListNode* pNode = pHead;
	while(pNode != NULL){
		nodes.push(pNode);		//入栈 
		pNode = pNode -> next;
	}
	while(!nodes.empty()){
		pNode = nodes.top();    
		cout << "从后到前打印链表" << pNode -> data ;
		nodes.pop();			//出栈
	cout << endl;
}