【数据结构】无头单向非循环链表

链表

首先我们来思考一个问题: 

为什么要有链表这种结构呢?

  上次我们写了顺序表, 其实本质上也就是一个数组, 它已经可以完成数据的存储和访问了, 但是它还存在一些不可避免的问题

  1. 顺序表的中间和头部的插入删除的时间复杂度都是O(n), 复杂度太高

  2. 增容的时候需要申请新的空间, 还要完成数据从旧空间到新空间的数据拷贝过程, 再释放旧空间, 消耗非常大

  3. 增容我们一般是增容两倍, 如果我们增容后现在只插入了很少的元素或者说只插入一个元素, 这个时候空间的浪费是非常

大的, 我们一定要避免这种问题.

  所以我们有了链表, 用一种链式的结构来存储, 在空间的消耗和浪费会远远优于顺序表, 那么什么是顺序表呢?

概念

  链表其实是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的

比如:

 

分类

链表其实有很多种 :

    1. 有头, 无头

    2. 单向, 双向

    3. 循环, 不循环

但是我们一般只讨论两种 :

    1. 无头单项非循环链表   

        结构简单，一般不会单独用来存数据, 实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等

    2. 带头双向循环链表

        结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。

那么在这篇博客中我们写的是第一种 : 无头单项非循环链表, 第二种我们会在后面的博客中给出

实现

我们主要实现的是头插头删, 尾插尾删, pos处的插入删除, 以及查找, 移除固定值的所有元素等功能

在这里我把pos处的插入删除做一个演示, 头插头删和尾插尾删更加简单

插入:

删除:

 

代码

LinkList.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int Datatype;
typedef struct ListNode
{
	Datatype _data;
	struct ListNode* _next;
}ListNode;

typedef struct LinkList
{
	ListNode* _head;
}List;


//初始化
void ListInit(List* ls);

//销毁
void ListDestroy(List* ls);

//创建结点
ListNode* BuyListNode(Datatype data);

//头插
void ListPushFront(List* ls, Datatype data);

//头删
void ListPopFront(List* ls);

//尾插
void ListPushBack(List* ls, Datatype data);

//尾删
void ListPopBack(List* plist);

//查找值为data的结点
ListNode* ListFind(List* plist, Datatype data);

//在pos的后面进行插入
void ListInsertAfter(ListNode* pos, Datatype data);


//删除POS后面的第一个结点
void ListEraseAfter(ListNode* pos);

//移除值为data的结点
void ListRemove(List* ls, Datatype data);

//打印
void ListPrint(List* ls);

Realize.c

#include "LinkList.h"

//初始化
void ListInit(List* ls)
{
	assert(ls);
	ls->_head = NULL;
}

//销毁
void ListDestroy(List* ls)
{
	assert(ls);
	ListNode* cur = ls->_head;
	ListNode* next;
	while (cur)
	{
		next = cur->_next;
		free(cur);
		cur = next;
	}
	ls->_head = NULL;
}

//创建结点
ListNode* BuyListNode(Datatype data)
{
	ListNode* pNode = (ListNode*)malloc(sizeof(ListNode));
	pNode->_data = data;
	pNode->_next = NULL;
	return pNode;
}

//头插
void ListPushFront(List* ls, Datatype data)
{
	assert(ls);
	ListNode* pNode = BuyListNode(data);
	assert(pNode);
	pNode->_next = ls->_head;
	ls->_head = pNode;
}

//头删
void ListPopFront(List* ls)
{
	assert(ls);
	assert(ls->_head);

	ListNode* cur = ls->_head;
	ListNode* next = cur->_next;
	free(cur);
	ls->_head = next;
}

//尾插
void ListPushBack(List* ls, Datatype data)
{
	assert(ls);
	ListNode* cur = ls->_head;
	while (cur->_next)
	{
		cur = cur->_next;
	}
	ListNode* newNode = BuyListNode(data);
	newNode->_data = data;
	newNode->_next = NULL;
	cur->_next = newNode;
}

//尾删
void ListPopBack(List* ls)
{
	assert(ls);
	assert(ls->_head);
	ListNode* cur = ls->_head;
	ListNode* next = cur->_next;
	if (next == NULL)
	{
		ListPopFront(ls);
		return;
	}
	while (next->_next)
	{
		cur = next;
		next = next->_next;
	}
	free(next);
	cur->_next = NULL;
}

//查找值为data的结点
ListNode* ListFind(List* ls, Datatype data)
{
	assert(ls);
	ListNode* cur = ls->_head;
	while (cur)
	{
		if (cur->_data == data)
		{
			printf("exits\n");
			return cur;
		}
		cur = cur->_next;
	}
	printf(" not exits\n");
	return NULL;
}

//在pos的后面进行插入
void ListInsertAfter(ListNode* pos, Datatype data)
{
	assert(pos);
	ListNode* newNode = BuyListNode(data);
	newNode->_next = pos->_next;
	pos->_next = newNode;
}


//删除POS后面的第一个结点
void ListEraseAfter(ListNode* pos)
{
	assert(pos);
	ListNode* next = pos->_next;
	pos->_next = next->_next;
	free(next);
}

//移除值为data的结点
void ListRemove(List* ls, Datatype data)
{
	assert(ls);
	assert(ls->_head);

	while (ls->_head != NULL && ls->_head->_data == data)
	{
		ListPopFront(ls);
	}
        if(ls->_head == NULL)
            return;
	ListNode* cur = ls->_head->_next;
	ListNode* prev = ls->_head;
	for (; cur != NULL; cur = prev->_next)
	{
		if (cur->_data == data)
		{
			prev->_next = cur->_next;
			free(cur);
		}
		else
		{
			prev = cur;
		}
	}
}

//打印
void ListPrint(List* ls)
{
	assert(ls);
	ListNode* cur = ls->_head;
	while (cur)
	{
		printf("%d -> ", cur->_data);
		cur = cur->_next;
	}
	printf("NULL\n");
}

main.c

#include "LinkList.h"

void test()
{
	List ls;
	ListInit(&ls);
	ListPushFront(&ls, 2);
	ListPushFront(&ls, 1);
	ListPushBack(&ls, 3);
	ListPushBack(&ls, 4);
	ListPrint(&ls);
	ListPopBack(&ls);
	ListPopBack(&ls);
	ListPrint(&ls);

	ListNode* pos = ListFind(&ls, 2);
	ListInsertAfter(pos, 5);
	ListInsertAfter(pos, 4);
	ListInsertAfter(pos, 3);
	ListInsertAfter(pos, 3);
	ListPrint(&ls);
	ListNode* ret = ListFind(&ls, 5);
	ListInsertAfter(ret, 3);
	ListInsertAfter(ret, 3);
	ListPrint(&ls);
	ListRemove(&ls, 3);
	ListPrint(&ls);
	ListDestroy(&ls);
}
int main()
{
	test();
	system("pause");
	return 0;	
}

上面就是无头单链表的简单实现^_^