单链表的基本操作

单链表作为数据结构的基础，数据机构作为算法的基础，算法作为offer的基础，所以单链表的重要性就不用我多说了吧

这篇博客是把单链表的基本操作详细介绍一遍，以巩固我对单链表指针的理解。

首先是定义部分：

struct Node
{
	int data;
	struct Node* next; 
};
typedef struct Node *List;

这个就不用我多说了吧，懂得都懂，不懂得查资料吧，我是用C语言完成的，创建新的节点用到了malloc函数，所以头文件就两个。

初始化：

void InitList(List plist)//初始化
{
	if(plist == NULL)
		return ;
	else
	{
		plist->next = NULL;
	}
}

这个也不用详细说了吧，我写的是带头结点的单链表，初始化当然就是创建一个头结点，然后头结点的next指向NULL就完事了

插入：

 头插：

bool Insert_head(List plist,int val)//头插
{
	if(plist == NULL)
	{
		return false;
	}
	else
	{
		Node* p = (Node*)malloc(sizeof(Node));
		p->data = val;
		p->next = plist->next;
		plist->next = p;	
	}
	return true;
}

头插和尾插还是得说说，头插就是从单链表的头部开始插入，这个头部是指头结点的下一个位置，这样的插入操作时间复杂度是O(1)，但同样造成的问题是插入的结果是反过来的，比如我插入1-10，那么在链表中结果就是从10-1，

                           

 再进行如图之后的操作，就变成如下的样子，其实在内存中由于链表的空间地址不一定，所以指向可能没有这么整齐，我只是为了好理解，才这么画的

                         

 尾插：

bool Insert_end(List plist,int val)//尾插
{
	if(plist == NULL)
	{
		return false ;
	}
	else
	{
		Node* p = (Node*)malloc(sizeof(Node));
		for(p = plist;p->next!=NULL;p=p->next);
		Node* q = (Node*)malloc(sizeof(Node));
		q->data = val;
		q->next = p->next;
		p->next = q;
	}
	return true;
}

尾插就是在尾部插入了，尾部的话，得先找到最后一个节点，然后直接插入就好了。时间复杂度是O（n），但是插入是正序插入。

查找：

Node* Search(List plist,int val)//查找
{
	if(plist == NULL)
	{
		return NULL;
	}
	Node* p = (Node*)malloc(sizeof(Node));
	for(p=plist->next;p!=NULL;p=p->next)
	{
		if(p->data == val)
		{
			return p;
		}
	}
	printf("查找失败！\n");
	
	return NULL;
	
}

我这里查找成功返回找到的节点，查找失败返回NULL，当然返回值也可以做成bool类型的。思路理解就行。

删除：

bool Delete(List plist,int val)//删除数据
{
	if(plist == NULL)
	{
		return false;
	}
	Node* p = (Node*)malloc(sizeof(Node));
	for(p = plist;p->next!=NULL;p=p->next)
	{
		if(p->next->data == val)
		{
			Node* q = p->next;
			p->next = q -> next;
			free(q);
			return true;
		}
	}
	return false;
}

删除一个节点，首先得找到这个节点，我本来想的是用查找函数找到，然后在进行删除，然后删除的时候报错了，删除之后的节点找不到了，可能是我操作问题，但本身这种想法是可以实现的

获取长度:

int GetLength(List plist)//获取长度
{
	if(plist == NULL)
	{
		return -1;
	}
	int count = 0;
	Node* p = (Node*)malloc(sizeof(Node));
	for(p = plist;p->next != NULL;p=p->next)
	{
		count++;
	}
	return count;
}

这个就是遍历一遍，没什么好说的。

判空：

int empty = 1;
bool IsEmpty(List plist)//判空
{
	if(plist == NULL)
	{
		empty = -1;
		return false;
	}
	return plist->next == NULL ? true : false;
}

判空这里我定义了一个全局变量，因为如果链表为空返回的也是false，我想做一下区分，其实这个区分做不做都可以，链表为空也就是没找到么。

清空数据：

void ClearData(List plist)//清除数据
{
	if(plist == NULL )
	{
		return ;
	}
	Node *p;
	Node *q = plist->next;
	while(q != NULL)
	{
		p = q -> next;
		free(q);
		q = p;
	}
	plist -> next = NULL;
}

销毁链表：

void Destroy(struct Node *pNode)//销毁
{
	if(pNode == NULL)
	{
		return ;
	}
	Node* p ;
	while(pNode->next != NULL)
	{
		p = pNode -> next;
		pNode->next = p->next;
		free(p);	
	}

}

这两个要放一起说，消除数据是清空链表中所有的节点，但链表还在，这里就是头结点还在；

而销毁链表就是彻底销毁链表，我这里头结点释放不了，一时间还没找到原因，所有功能上和清空数据是差不多的，有人看出来问题在哪里了欢迎给我说一下！

打印：

void Show(List plist)//打印
{
	if(plist == NULL || plist->next == NULL)
	{
		printf("没有数据！");
		return;
	}
	else
	{
		Node *p = (Node*)malloc(sizeof(Node));
		p = plist->next;
		while(p!=NULL)
		{
			printf("%d ",p->data);
			p = p->next;
		}
		printf("\n");
	}

}

打印也没什么好说的了，这里要提一下，遍历链表时

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

for(p = plist;p->next != NULL;p = p->next);'

 这两个遍历是不一样的，具体情况要具体使用，看你自己的考虑了

测试用例：

int main()
{
	Node head;
	InitList(&head);
	if(IsEmpty(&head))
	{
		printf("%d\n",empty);
	}
	int i;
	for(i = 0;i < 10;i++)
	{
		Insert_end(&head,i);
		//Insert_head(&head,i);
	}
	Delete(&head,3);
	
	Show(&head);
	if(!IsEmpty(&head))
		printf("链表不空！\n");
	printf("链表的长度为：%d\n",GetLength(&head));

	//ClearData(&head);
	//Show(&head);
	Node* p;
	p = Search(&head,3);
	if(p!= NULL)
	{
		printf("%d ",p->data);
	}
	

	Destroy(&head);
	Destroy(&head);
	return 0;
}

总结：

数据结构的重要性不必多说，一个单链表的基本操作写下来也就一两百行，真的不算难，自己画图着写，我是花了一个多小时就写完了，但是调试确实用了很久，但是自己的调试能力也上了一层楼，所以只要肯付出，这些都不算难。