C的数据结构---带头单链表2

Yhp_Single_LinkList.h

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

typedef int ElemType;

typedef struct LinkNode
{
	ElemType data;
	struct LinkNode *next;
}LinkNode,*LinkList;

LinkNode* BuyNode();

LinkList InitList();

void Freenode(LinkNode *p);

void PrintList(LinkList head);

LinkNode* FindValue_Pre(LinkList head, ElemType val);

LinkNode* FindValue(LinkList head, ElemType val);

LinkNode* FindPos_Pre(LinkList head, int pos);

LinkNode *FindPos(LinkList head, int pos);

bool Insert_Next(LinkList head, LinkNode *ptr, ElemType val);

void Push_Front(LinkList head, ElemType val);

void Push_Back(LinkList head, ElemType val);

bool InsertPos(LinkList head, int pos, ElemType val);

bool Erase_Next(LinkList head, LinkNode *ptr);

void Pop_Front(LinkList head);

void Pop_Back(LinkList head);

bool IsEmpty(LinkList head);

int GetSize(LinkList head);

bool Remove(LinkList head, ElemType val);

void Remove_ALL(LinkList head, ElemType val);

void ClearList(LinkList head);

void DestroyList(LinkList head);

.cpp

#include"Yhp_Single_LinkList.h"

LinkNode* BuyNode()
{
	LinkNode *s = (LinkNode*)malloc(sizeof(LinkNode));
	if (s == NULL)
	{
		exit(1);
	}
	memset(s, 0, sizeof(LinkNode));
	return s;
}

LinkList InitList()
{
	return BuyNode();
}


void Freenode(LinkNode *p)
{
	free(p);
}

void PrintList(LinkList head)
{
	assert(head != NULL);
	LinkNode *p = head;
	while (p->next != NULL)
	{ 
		p = p->next;
		printf("%d ", p->data);
	}
	printf("\n");
}


LinkNode* FindValue_Pre(LinkList head, ElemType val)
{
	assert(head != NULL);
	LinkNode *prev = head;
	LinkNode *p = head->next;
	while (p != NULL && p->data != val)
	{
		prev = p;
		p = p->next;
	}

	if (NULL == p)
	{
		prev = NULL;
	}

	return prev;
}


LinkNode* FindValue(LinkList head, ElemType val)
{
	assert(head != NULL);
	LinkNode *p = FindValue_Pre(head, val);
	if (p != NULL)
	{
		p = p->next;
	}
	return p;
}


LinkNode* FindPos_Pre(LinkList head, int pos)
{
	assert(head != NULL);
	if (pos < 1)
	{
		return NULL;
	}
	int i = 1;
	LinkNode *pre = head;
	LinkNode *p = head->next;
	while (p != NULL && i < pos)
	{
		pre = p;
		p = p->next;
		++i;
	}
	if (p == NULL)
	{
		pre = NULL;
	}
	return pre;
}


LinkNode *FindPos(LinkList head, int pos)
{
	assert(head != NULL);
	LinkNode *p = FindPos_Pre(head, pos);
	if (p != NULL)
	{
		p = p->next;
	}
	return p;
}


bool Insert_Next(LinkList head, LinkNode *ptr, ElemType val)
{
	assert(head != NULL);
	if (ptr == NULL)
	{
		return false;
	}
	LinkNode *newnode = BuyNode();
	newnode->data = val;
	newnode->next = ptr->next; 
	ptr->next = newnode;
	return true;
}

void Push_Front(LinkList head, ElemType val)
{
	assert(head != NULL);
	Insert_Next(head, head, val);
}

void Push_Back(LinkList head, ElemType val)
{
	assert(head != NULL);
	LinkNode *p = head;
	while (p->next != NULL)
	{
		p = p->next;
	}
	Insert_Next(head, p, val);
}

bool InsertPos(LinkList head, int pos, ElemType val)
{
	assert(head != NULL);
	if (pos < 1)
	{
		return false;
	}
	int i = 1;
	LinkNode *p = head;

	while (p->next != NULL&&i < pos)   //退出循环时，i == pos 但是 p指向的是pos的前一个结点
	{                                  // 因为 i是从1开始的
		p = p->next; 
		++i;
	}

	if (pos > i)
	{
		return false;
	}

	return Insert_Next(head, p, val);
}


bool Erase_Next(LinkList head, LinkNode *ptr)
{
	assert(head != NULL);
	if (ptr == NULL || ptr->next == NULL)
	{
		return false;
	}
	LinkNode *q = ptr->next;
	ptr->next = q->next;
	Freenode(q);
	q = NULL;
	return true;
}

void Pop_Front(LinkList head)
{
	assert(head != NULL);
	Erase_Next(head, head);
}

void Pop_Back(LinkList head)
{
	assert(head != NULL);
	LinkNode *p = head;
	LinkNode *pre = head;
	while (p->next != NULL)
	{
		pre = p;
		p = p->next;
	}
	Erase_Next(head, pre);
}

bool IsEmpty(LinkList head)
{
	assert(head != NULL);
	return head->next == NULL;
}

int GetSize(LinkList head)
{
	assert(head != NULL);
	int i = 0;
	LinkNode *p = head;
	while (p->next != NULL)
	{
		p = p->next;
		++i;
	}
	return i;
}

/***********************************************
void Remove(LinkList head, ElemType val)
{
	assert(head != NULL);
	LinkNode *p = head->next;
	LinkNode *pre = head;
	while (p != NULL && p->data != val)
	{
		pre = p;
		p = p->next;
	}
	if (p != NULL)
	{
		pre->next = p->next;
		Freenode(p);
		p = NULL;
	}
	else
	{
		return;
	}
}
*******************************************/
//优化后：
bool Remove(LinkList head, ElemType val)
{
	assert(head != NULL);
	return Erase_Next(head, FindValue_Pre(head, val));
}

void Swap(ElemType *ap, ElemType *bp)
{
	ElemType tmp = *ap;
	*ap = *bp;
	*bp = tmp;
}

void Remove_ALL(LinkList head, ElemType val)
{
	assert(head != NULL);
	LinkNode *pre = head;
	LinkNode *p = head->next;
	while (p != NULL)
	{
		if (p->data != val)              //如果第一个结点的 data!=val 则第一个结点自身交换 
		{
			pre = pre->next;        
			Swap(&pre->data, &p->data);  //把 !=val 移动到链表左边
			PrintList(head);
		}
		p = p->next;
	}
	while (pre->next != NULL)
	{
		Erase_Next(head, pre);
	}
}

void ClearList(LinkList head)
{
	assert(head != NULL); 
	while (!IsEmpty(head))
	{
		Pop_Front(head);      //头删最快
	}
}

void DestroyList(LinkList head)
{
	assert(head != NULL);
	ClearList(head);
	Freenode(head);
}