单链表实现

SList.h

#ifndef __SLIST_H__
#define __SLIST_H__

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

#define ElemType int

typedef struct Node  //定义一个结点类型为Node  并定义一个指针类型*PNode
{
	ElemType data;
	struct Node* next;
}Node,*PNode;

typedef struct List
{
	PNode  first;  //first指针用来指向头部  类型为PNode指针 指向的是struct Node结构体
	PNode  last;   //last指针指向尾部
	size_t size;
}List;


void Init(List* list);//初始化函数声明
void push_back(List* list,ElemType x);//尾插函数声明
void show_list(List* list);//显示函数声明
void push_front(List* list,ElemType x);//头插函数声明
void pop_back(List* list);//尾删函数声明
void pop_front(List* list);//头删函数声明
void insert_val(List* list,ElemType x);//按值插入函数声明
Node* find(List* list,ElemType k);//查找函数声明
int  length(List* list);//求长度函数声明 
void delete_val(List* list,ElemType k);//按值删除函数声明
void sort(List* list);//排序函数声明
void resever(List* list);//逆置函数声明
void clear(List* list);//清除函数声明
void destroy(List* list);//摧毁函数声明
#endif 

test.c

#include"SList.h"

int main()
{
	int input=0;
	List mylist;
	Init(&mylist);
	ElemType Item;
	Node* p=NULL;
	do
	{
		printf("****************************\n");
		printf("* [1] 尾插     [2] 头插    *\n");
		printf("* [3] 展示     [4] 尾删    *\n");
		printf("* [5] 头删     [6] 按值插入*\n");
		printf("* [7] 查找     [8] 长度    *\n");
		printf("* [9] 按值删除 [10] 排序   *\n");
		printf("* [11] 逆置    [12] 清除   *\n");
		printf("* [13] 摧毁    [14] 退出   *\n");
		printf("****************************\n");
		printf("请选择：>");
		scanf("%d",&input);
		if (input==0)
		{
			printf("即将退出程序\n");
			break;
		}
		switch (input)
		{
		case 1:
			printf("请输入要尾插入的数据(-1结束)");
			while(scanf("%d",&Item),Item!=-1)
			{
				push_back(&mylist,Item);
			}
			break;
		case 2:
			printf("请输入要头插入的数据(-1结束)");
			while(scanf("%d",&Item),Item!=-1)
			{
				push_front(&mylist,Item);
			}
			break;
		case 3:
			show_list(&mylist);
			break;
		case 4:
			pop_back(&mylist);
			break;
		case 5:
			pop_front(&mylist);
			break;
		case 6:
			printf("请输入要插入的数据：>");
			scanf("%d",&Item);
			insert_val(&mylist,Item);
			break;
		case 7:
			printf("请输入要查找的数据：>");
			scanf("%d",&Item);
			p=find(&mylist,Item);
			if (p==NULL)
			{
				printf("要查找的数据在链表中不存在\n");
			}
			break;
		case 8:
			printf("链表的长度为 %d\n",length(&mylist));
			break;
		case 9:
			printf("请输入要删除的值：>");
			scanf("%d",&Item);
			delete_val(&mylist,Item);
			break;
		case 10:
			sort(&mylist);
			break;
		case 11:
			resever(&mylist);
			break;
		case 12:
			clear(&mylist);
			break;
		case 13:
			destroy(&mylist);
			break;
		default :
			printf("选择错误，请重新选择");
			break;
		}
	}
	while(input);

	return 0;
}

SList.c

#include"SList.h"

//初始化函数实现
void Init(List* list)
{
	list->first=list->last=(Node*)malloc(sizeof(Node));
	assert(list->first&&list->last);
	list->size=0;
	list->first->next=NULL;
}

//尾插函数实现
void push_back(List* list,ElemType x)
{
	Node* s=(Node*)malloc(sizeof(Node));
	assert(s);
	s->data=x;
	s->next=NULL;
	list->last->next=s;
	list->last=s;
	list->size++;
}

//头插函数实现
void push_front(List* list,ElemType x)
{
	Node* s=(Node*)malloc(sizeof(Node));
	assert(s);
	s->data=x;
	s->next=list->first->next;
	list->first->next=s;
	if(list->size==0)
	{
		list->last=s;
	}
	list->size++;
}

//显示函数实现
void show_list(List* list)
{
	Node* p=list->first->next;  //将next指针交给p 使得p指向结点
	while (p)
	{
		printf("%d-->",p->data);
		p=p->next;
	}
	printf("Nul\n");
}

//尾删函数实现
void pop_back(List* list)
{
	if (list->size==0)
	{
		return;
	}
	Node* p=list->first;
	while(p->next!=list->last)
	{
		p=p->next;
	}
	free(list->last);
	list->last=p;
	list->last->next=NULL;
	list->size--;
}

//头删函数实现
void pop_front(List* list)
{
	if (list->size==0)
	{
		return ;
	}
	Node* p=list->first->next;
	list->first->next=p->next;
	free(p);
	if (list->size==1)
	{
		list->last=list->first;
	}
	list->size--;
}

//按值插入函数实现
void insert_val(List* list,ElemType x)  //插入数据之前的单链表是有序的  否则这函数没啥意义 
{
	Node* s=(Node*)malloc(sizeof(Node));
	assert(s);
	s->data=x;
	s->next=NULL;

	Node* p=list->first;
	while(p->next!=NULL && p->next->data<x)
	{
		p=p->next;
	}
	if (p->next==NULL)
	{
		list->last=s;
	}
	s->next=p->next;
	p->next=s;
	list->size++;
}

//查找函数实现
Node* find(List* list,ElemType k)
{
	Node* p=list->first->next;
	while (p!=NULL && p->data!=k)
	{
		p=p->next;
	}
	return p;
}

//求长度函数实现
int length(List* list)
{
	return list->size;
}

//按值删除函数实现
void delete_val(List* list,ElemType k)
{
	if (list->size==0)
	{
		return ;
	}
	Node* p=find(list,k);
	if (p==NULL)
	{
		printf("要删除的数据不存在\n");
		return ;
	}
	if(p==list->last)
	{
		pop_back(list);
	}
	else
	{
		Node* q = p->next;
		p->data = q->data;
		p->next = q->next;
		free(q);
		list->size--;
	}
}

//排序函数实现
void sort(List* list)
{
	if(list->size==0 || list->size==1)
	{
		return ;
	}
	Node* s=list->first->next;
	Node* q=s->next;

	list->last=s;
	list->last->next= NULL;
	while (q)
	{
		s=q;
		q=q->next;
		Node* p=list->first;
		while(p->next!=NULL && p->next->data<s->data)
		{
			p=p->next;
		}
		if (p->next==NULL)
		{
			list->last=s;
		}
		s->next=p->next;
		p->next=s;
	}
}

//逆置函数实现
void resever(List* list)
{
	if(list->size==0 || list->size==1)
	{
		return ;
	}
	Node* p=list->first->next;
	Node* q=p->next;
	list->last=p;
	list->last->next=NULL;

	while (q)
	{
		p=q;
		q=p->next;
		p->next=list->first->next;
		list->first->next=p;
	}
}

//清除函数实现
void clear(List* list)
{
	if(list->size==0)
		return ;
	Node* p=list->first->next;
	while (p)
	{
		list->first->next=p->next;
		free (p);
		p=list->first->next;
	}
	list->last=list->first;
	list->size=0;
}

//摧毁函数实现
void destroy(List* list)
{
	clear(list);
	free(list->first);
	list->first=list->last=NULL;
}