头插入法

在初始化之后，就可以着手开始创建单链表了，单链表的创建分为头插入法和尾插入法两种，两者并无本质上的不同，都是利用指针指向下一个结点元素的方式进行逐个创建，只不过使用头插入法最终得到的结果是逆序的。
如图，为头插法的创建过程：

该方法从一个空表开始，生成新结点，并将读取到的数据存放到新结点的数据域中，然后将新结点插入到当前链表的表头，即头结点之后。

//初始化单链表，使用头插法建立单链表
LinkedList LinkedListCreatH() {
    Node *L;
    L = (Node *)malloc(sizeof(Node)); //申请头结点空间
    L->next = NULL; //初始化一个空链表
    }
    int x;  //x为链表数据域中的数据
    while(scanf("%d",&x) != EOF) {
        Node *p;
        p = (Node *)malloc(sizeof(Node));  //申请新的结点
        p->data = x;  //结点数据域赋值
        p->next = L->next; //将结点插入到表头L-->|2|-->|1|-->NULL
        L->next = p;
    }
    return L;

// 链表的创建和遍历
link * initLink(){
    link * p=(link*)malloc(sizeof(link));//创建一个头结点
    link * temp=p;//声明一个指针指向头结点，用于遍历链表
    //生成链表
    for (int i=1; i<5; i++) {
        link *a=(link*)malloc(sizeof(link));
        a->elem=i;
        a->next=NULL;
        temp->next=a;
        temp=temp->next;
    }
    return p;
}

尾插入法

头插法建立单链表的算法虽然简单，但生成的链表中结点的次序和输入数据的顺序不一致。若希望两者次序一致，可采用尾插法。

该方法是将新结点逐个插入到当前链表的表尾上，为此必须增加一个尾指针 r, 使其始终指向当前链表的尾结点，否则就无法正确的表达链表。

//初始化单链表，尾插法建立单链表
LinkedList LinkedListCreatT() {
    Node *L;
    L = (Node *)malloc(sizeof(Node));   //申请头结点空间
    L->next = NULL;                  //初始化一个空链表
    Node *r;
    r = L;                          //r始终指向终端结点，开始时指向头结点
    int x;                         //x为链表数据域中的数据
    while(scanf("%d",&x) != EOF) {
        Node *p;
        p = (Node *)malloc(sizeof(Node));   //申请新的结点
        p->data = x;                     //结点数据域赋值
        r->next = p;            //将结点插入到表头L-->|1|-->|2|-->NULL
        r = p;
    }
    r->next = NULL;
    return L;
}

链表（增删改查/遍历/元素个数）

链表结构体声明：

首先，在创建一个链表之前，我们要先创建一个链表单个节点的结构体，分别包含数据域和指针域，具体实现如下：

typedef struct node{
	int data;               //数据域
	struct node *next;      //指针域（结构体类型指针）
}Node,*Link; //取别名 Node 和 结构体指针类型 Link

单链表的创建：

创建一个带有头结点的链表，虽然不是必须的，但是很方便。

Link create()
{
	Link head = NULL; //初始化Link指针指向null
	head = (Link)malloc(sizeof(Node));//申请新节点
	if(head == NULL)
	{
		printf("动态内存分配失败");
		return NULL; 
	}
	head->data = 0;            //数据域赋初始值
	head->next = NULL;         //指针域赋初始值
	
	return head;
} 

单链表的插入：

头插法增加节点：（插入顺序为反向）

void head(Link head,int num)
{
	Link p,pr;
	p = head->next;				//p为头结点的下一个 
	pr = NULL;					//pr为新插入的结点 插在head后p前 
	pr = (Link)malloc(sizeof(Node));
	
	if(pr == NULL)
	{
		printf("动态内存分配失败");
		return ;
	}
	
	pr->data = num;		//给pr数据域赋值 
	
	pr->next = p;		//头插！
	head->next = pr;
	
	return ; 
 } 

尾插法增加节点：（插入顺序为正向）

void rear(Link head,int num)
{
	Link p = head;
	Link pr = NULL;		//pr为新增节点
	
	pr = (Link)malloc(sizeof(Node));
	if(pr == NULL)
	{
		printf("动态内存分配失败");
		return ; 
	}
	
	pr->data = num;				//数据域赋值 
	if(head->next == NULL)		//如果头结点下一个为空，就可以直接插入 
	{
		head->next = pr;		//插在头结点后一个 
		pr->next = NULL;		//插完后就指向空结束了 
	} 
	else
	{
		while(p->next != NULL)	//头节点不指向空，就先循环遍历链表找到最后一个再插进去 
		{
			p = p->next;
		}
		p->next = pr;			//尾插！ 
		pr->next = NULL;
	} 
	return； 
}

单链表的删除：

void deletenode(Link head,int n)	//传入链表和要删除的数
{
	Link p = NULL,pr = NULL;	//定义一前一后两个节点
	p = head;
	pr = head->next;
	
	if(head == NULL)
	{
		printf("链表为空，没有可删除的值");
		return ; 
	}
	
	while(pr->data != n && pr->next != NULL)	//没遍历到要删除的值，并且不指空，就接着遍历
	{
		p = pr;		//删除操作，前保存后
		pr = pr->next; 
	}
	
	 //出循环有两种情况：
	 //1.找到要删除的值了
	 //2.整个链表遍历到最后也没找到，
	 //  也就是说这个传入的要删除的值根本不存在链表当中 
	 
	 if(pr->data == n)
	 {
	 	if(pr == head)			//优先考虑，pr为头节点，直接给head保存，最后一起释放pr 
	 	{
	 		head->next = pr->next;
		}
		else
		{
			p->next = pr->next 	//前面p保存后面pr，最后一起释放pr 
		}
		free(pr);
		printf("删除成功！"); 
	 } 
	 else
	 {
	 	printf("未找到要删除的值"); 
	 }
	 
	 return ;
	 
 } 

单链表的修改：

void fix(Link head,int m)		//传入链表和要改动的值
{
	Link pr;
	pr = head->next;
	
	int fixnum;
	if(head == NULL)
	{
		printf("链表为空，无可删除的数据");
		return ;
	}
	
	while(pr->next != NULL)		//遍历整个链表
	{
		if(pr->data == m)
		{
			printf("请输入新值：");
			scanf("%d",&fixnum);
			pr->data = fixnum;		//给pr数据域赋新的值
			
			return;					//修改完毕直接结束执行此函数 
		}
		pr = pr->next;			//没找到则一直遍历 
	}
	
	printf("未找到可以修改的值");	//出循环还没找到就是这个值不存在
	
	return; 
	 
 } 

单链表的查询：

void search(Link head,int x)	//传入整个链表和要查询的值
{
	Link p;
	p = head;
	if(head == NULL)
	{
		printf("链表为空，无可查询的数据");
		return ; 
	}
	
	p->data = x;
	int searchnode;
	printf("输入带查询的数：");
	scanf("%d",&searchnode);
	
	while(p->data != searchnode && p->next != NULL)	//如果不是查询的值并且指向不为空，就进入循环遍历 
	{
		p = p->next;
	}
	
	//出循环就是两种情况（和删除修改一样）
	if(p->data == searchnode)
	{
		printf("查询结果：%d",searchnode);
		return ;					//找到直接退出函数执行 
	}
	else
	{
		printf("未找到要查询的值");
	}
	
	return ; 
} 

链表的陈列（遍历）：

void display(Link head)
{
	Link pr = head->next;
	while(pr != NULL)			//注意陈列打印的条件 
	{
		printf("%d\t",pr->data);
		pr = pr->next; 
	}
	return ;
}

链表的元素个数：

void displaynode(Link head)
{
	Link pr = head->next;
	int count = 0;
	
	while(pr != NULL)
	{
		pr = pr->data;
		cnt++; 
	}
	printf("%d",count);
	
	return ;
}