单链表【有头结点】

单链表 带有头结点的

.h文件

#ifndef MY_LINKLIST_H
#define MY_LINKLIST_H
typedef int ElemType;
typedef struct ListNode
{
	ElemType data;
	struct ListNode* next;
}ListNode;

typedef struct
{
	ListNode* head;
	int cursize;
}LinkList;

int GetSize(LinkList* plist);//结点个数

bool IsEmpty(LinkList* plist);//链表判空

ListNode* Buynode();//获得一个结点

void Freenode(ListNode* p);//释放结点

void Init_List(LinkList* plist);//初始化

void Destroy_List(LinkList* plist);//摧毁
void Clear_List(LinkList* plist);//清除

void Insert_Item(LinkList* plist, ListNode* ptr, ElemType val);//插入一个元素

void PrintList(LinkList* plist);//输出

ListNode* FindPos_Pre(LinkList* plist, int pos);//按位置查询前驱结点

ListNode* FindPos(LinkList* plist, int pos);//按位置查询位置

void Push_Front(LinkList* plist, ElemType val);//头插

void Push_Back(LinkList* plist, ElemType val);//尾插

void Insert_Back(LinkList* plist, ElemType* first, ElemType* last);//数组插入链表

void Erase_Next(LinkList* plist, ListNode* ptr);//删除元素

void Pop_Front(LinkList* plist);//删除链表首元素

void Pop_Back(LinkList* plist);//删除链表尾元素

ListNode* FindValue_Pre(LinkList* plist, ElemType val);//返回val的前驱

ListNode* FindValue(LinkList* plist, ElemType val);//返回val

void Remove(LinkList* plist, ElemType val);//将含有val的元素从链表中删除

void Remove_All(LinkList* plist, ElemType val);//将含有val的全部元素从链表中删除

void SortList(LinkList* plist);//快排

void Meger_List(LinkList* aplist,LinkList* bplist,LinkList* cplist)；//两个链表合并,数据按照由小到大链接
    
void ReverseList(LinkList* plist)；//逆向函数

.cpp文件

#include<stdio.h>
#include<stdlib.h> 
#include<assert.h>
#include<string.h>
#include"My_LinkList.h"

int GetSize(LinkList* plist)
{
	assert(plist != nullptr);
	return plist->cursize;
}
bool IsEmpty(LinkList* plist)
{
	return GetSize(plist) == 0;
}
ListNode* Buynode()
{
	ListNode* s = (ListNode*)malloc(sizeof(ListNode));
	if (nullptr == s)
	{
		fprintf(stderr, "malloc fail \n");
		exit(1);
	}
	memset(s, 0, sizeof(ListNode));
	return s;
}
void Freenode(ListNode* p)
{
	free(p);
}
void Init_List(LinkList* plist)
{
	assert(plist != nullptr);
	ListNode* s = Buynode();
	s->next = nullptr;
	plist->head = s;
	plist->cursize = 0;
}
void Insert_Item(LinkList* plist, ListNode* ptr, ElemType val)
{
	assert(plist != nullptr && ptr != nullptr);
	ListNode* s = Buynode();
	s->data = val;
	s->next = ptr->next;
	ptr->next = s;
	plist->cursize += 1;
}

void PrintList(LinkList* plist)
{
	assert(plist != nullptr);
	ListNode* p = plist->head->next;
	while (p != nullptr)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}
ListNode* FindPos_Pre(LinkList* plist, int pos)
{
	assert(plist != nullptr);
	if (pos < 1 || pos > plist->cursize + 1)
	{
		return nullptr;
	}
	ListNode* p = plist->head;
	for (int i = 1; i < pos; ++i)
	{
		p = p->next;
	}
	return p;
}
ListNode* FindPos(LinkList* plist, int pos)
{
	ListNode* p = FindPos_Pre(plist, pos);
	if (p != nullptr)
	{
		p = p->next;
	}
	return p;
}

void Push_Front(LinkList* plist, ElemType val)
{
	Insert_Item(plist, plist->head, val);
}

void Push_Back(LinkList* plist, ElemType val)
{
	ListNode* pre = FindPos_Pre(plist, plist->cursize + 1);
	Insert_Item(plist, pre, val);
}
void Insert_Back(LinkList* plist, ElemType* first, ElemType* last)
{
	for (; first != last; ++first)
	{
		Push_Back(plist, *first);
	}
}


void Erase_Next(LinkList* plist, ListNode* ptr)
{
	assert(plist != nullptr && ptr != nullptr);
	ListNode* q = ptr->next;
	if (q != nullptr)
	{
		ptr->next = q->next;
		Freenode(q);
		plist->cursize -= 1;
	}
}
void Pop_Front(LinkList* plist)
{
	assert(plist != nullptr);
	Erase_Next(plist, plist->head);
}
void Pop_Back(LinkList* plist)
{
	assert(plist != nullptr);
	Erase_Next(plist, FindPos_Pre(plist, plist->cursize));
}

ListNode* FindValue_Pre(LinkList* plist, ElemType val)
{
	assert(plist != nullptr);
	ListNode* p = plist->head; // 
	while (p->next != nullptr && p->next->data != val)
	{
		p = p->next;
	}
	if (p->next == nullptr)
	{
		p = nullptr;
	}
	return p;
}
ListNode* FindValue(LinkList* plist, ElemType val)
{
	assert(plist != nullptr);
	ListNode* p = FindValue_Pre(plist, val);
	if (p != nullptr)
	{
		p = p->next;
	}
	return p;
}
void Remove(LinkList* plist, ElemType val)
{
	assert(plist != nullptr);
	ListNode* pre = FindValue_Pre(plist, val);
	if (pre != nullptr)
	{
		Erase_Next(plist, pre);
	}
}
void Remove_All(LinkList* plist, ElemType val)
{
	assert(plist != nullptr);
	ListNode* p = plist->head;
	while (p->next != nullptr)
	{
		if (p->next->data == val)
		{
			//ListNode* q = p->next;
			//p->next = q->next;
			//Freenode(q);
			//plist->cursize -= 1;
			//continue;
			Erase_Next(plist, p);
		}
		else
		{
			p = p->next;
		}
	}
}
 
void Destroy_List(LinkList* plist)
{
	assert(plist != nullptr);
	Clear_List(plist);
	Freenode(plist->head);
	plist->head = NULL;
}
void Clear_List(LinkList* plist)
{
	assert(plist != nullptr);
	//while (plist->head->next != nullptr)
	//{
	//	Erase_Next(plist, plist->head);
	//}
	while (!IsEmpty(plist))
	{
		Pop_Front(plist);
		//Pop_Back(plist);
	}
}

void Swap_Int(int* ap, int* bp)
{
	int tmp = *ap;
	*ap = *bp;
	*bp = tmp;
}
ListNode* ListParition(ListNode* first, ListNode* end)//划分函数
{
	ListNode* jp = first;
	ListNode* ip = first->next;
	ElemType tmp = ip->data;
	while (ip != end)  // ip <end
	{
		if (ip->data <= tmp)
		{
			jp = jp->next;
			Swap_Int(&ip->data, &jp->data);
		}
		ip = ip->next;
	}
	Swap_Int(&jp->data, &first->next->data);
	return jp;
}
void QuickPass(ListNode* first, ListNode* end)
{
	if (first != end)
	{
		ListNode* p = ListParition(first, end);
		QuickPass(first, p);
		QuickPass(p, end);
	}
}
void SortList(LinkList* plist)
{
	assert(plist != nullptr);
	QuickPass(plist->head, nullptr);
}

void Meger_List(LinkList* aplist,LinkList* bplist,LinkList* cplist)
{
	assert(aplist!= nullptr&&bplist!= nullptr&&cplist!= nullptr);
	ListNode* ap=aplist->head->next;
    ListNode* bp=bplist->head->next;
    ListNode* cp=cplist->head;
    aplist->head->next=nullptr;
    aplist->head->next=nullptr;
    cplist->cursize=aplist->cursize+bplist->cursize;
    aplist->cursize=bplist->cursize=0；
    while(ap!=nullptr&&bp!=nullptr)
    {
        if(ap->data<bp->data)
        {
            s->next=ap;
            ap=ap->next;
        }
        else
        {
            s->next=bp;
            bp=bp->next;
        }
        s=s->next;
    }
    if(ap!=nullptr) s->next=ap;
    if(bp!=nullptr) s->next=bp;
}

void ReverseList(LinkList* plist)
{
    assert(plist != nullptr);
    if(plist->cursize<=1) return;
    ListNode* s=nullptr;
    ListNode* p=plist->head->next;//first
    plist->head->next=nullptr;
    while(p!=nullptr)
    {
        s=p;
        p=p->next;
        s->next=plist->head->next;
        plist->head->next=s;
    }
}