temp->data 等价于 (\*temp).data

任意位置插入节点

Node* head;
head = null;
temp = new Node(); //创建一个节点
temp->data = 4;   //节点值设为4
temp->link = NULL;  //link值设为空（因为要做尾节点）
Node* temp1 = A;  //新建一个临时元素，用来遍历链表
while (temp1->llink != NULL)   //遍历找到link为空的节点（尾节点）
{
	temp1 = temp1->link;
}
temp1->link = temp;  //将插入的前的尾节点的link值设置为要插入的节点的地址

头插法

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

struct Node {    //定义一个节点
	int data;
	struct Node* next; 
};

struct Node* head;   //头节点head设置为全局变量
void Insert(int x)   //定义插入函数
{
	Node* temp = (Node*)malloc(sizeof(struct Node));//为节点分配空间,注意:必须进行转换，因为malloc返回一个void类型指针
	temp->data = x;   //定义新建节点的值
	temp->next = head;  //head可以看成head->next 这也涵盖链表为空情况
	head = temp;  //将头节点head的指向下一个的指针设为temp的地址   

	//Node* temp1 = head;
	//while (temp1->next != NULL)
	//{
	//	temp1 = temp1->next;
	//}
	//temp1->next = temp;

}
void Print() //迭代打印链表  占用空间多  
{
	struct Node* temp = head;   
	printf("列表是：");
	while (temp != NULL)  //遍历链表
	{
		printf("%d", temp->data); 
		temp = temp->next;  //往下走
	}
	printf("\n");

}
int main()
{
	int n, x, i;
	head = NULL; //头节点设为空
	printf("请输入你想输入的数字个数:");
	scanf("%d", &n);
	for (i = 0; i < n; i++)
	{
		printf("请输入数字:\n");
		scanf("%d", &x);
		Insert(x);
		Print();
	}
}

任意位置插入一个节点

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

struct Node {
	int data;
	struct Node* next;
};

struct Node* head;
void Insert(int x, int n)
{
	Node* temp1 = (Node*)malloc(sizeof(struct Node));//为节点分配空间,注意:必须进行转换，因为malloc返回一个void类型指针
	temp1->data = x;    //定义新节点的值
	temp1->next = NULL;  //head可以看成head->next 这也涵盖链表为空情况

	if (n == 1)   //特殊情况 当n=1时 无前驱节点
	{
		temp1->next = head;  
		head = temp1;
		return;
	}
	Node* temp2 = head;   //新建一个node 用于定位要插入元素的前驱节点
	for (int i = 0; i < n - 2; i++)  //n-2正好是n-2+1=n-1
	{
		temp2 = temp2->next;
	}
	temp1->next = temp2->next;     
	temp2->next = temp1;

}
void Print() //迭代打印链表  占用空间多
{
	struct Node* temp = head;
	printf("列表是：");
	while (temp != NULL)  //遍历节点
	{
		printf("%d", temp->data);
		temp = temp->next;
	}
	printf("\n");

}
int main()
{
	head = NULL; //head为NULL
	Insert(2, 1); //list:2
	Print();
	Insert(3, 2);//list:2,3
	Print();
	Insert(4, 1);//lsit:4,2,3
	Print();
	Insert(5, 2);//lsit:4,5,2,3
	Print();
}

删除指定元素

void Delte(int n)
{
	struct Node* temp3 = head; //定义一个Node
	if (n == 1) //特殊情况
	{
		head = temp3->next; //将头节点指向第2个节点
		free(temp3); //释放第一个节点的空间
		return;
	}
	else
	{
		for (int i = 0; i < n - 2; i++)
		{
			temp3 = temp3->next;
		}
		struct Node* temp4 = temp3->next;  //此时temp4保存的位置为n的节点
		temp3->next = temp4->next;  //将n-1(temp3)的节点指向n+1(temp4->next)的节点
		free(temp4); //释放temp4的空间
	}
}

反转一个链表

void Reverse()
{
	struct Node* current, * next, * prev;
	//定义三个node变量,用来记录当前节点,前节点和后节点的地址
	current = head;  //将cuurent指针指向头节点
	prev = NULL;  //将prev指针指向的地址为空
	while (current != NULL)
	{
		next = current->next;  //用next来存储当前节点存储的后节点的地址
		current->next = prev;
		//将当前存储的后节点的地址改成前节点的地址,与后节点断开与前节点相连  
		prev = current;  //将prev指针指向当前节点
		current = next;  //将当前节点后移
	}
	head = prev;  //设置头节点指向(正序)末尾
}

递归打印链表

void Print(struct Node* head) //传入头节点
{
	if (head == NULL)  //特殊情况 列表为空
		return;
	printf("%d ", head->data);  //当需要逆序打印链表时,只需要将递归调用放在前面
	Print(head->next);  
}

递归反转链表

void Reverse2(struct Node* current) //传入指向头节点的指针
{
	if (current->next == NULL)   //将head指向正序最后一个节点
	{
		head = current;
		return;
	}
	Reverse2(current->next);  //递归调用
	struct Node* link = current->next; //记录存储下一节点的地址
	link->next = current;  //将下一节点的next指向当前节点
	current->next = NULL;  //将当前节点的next设置为空
}

双向链表

#include <stdio.h>
#include <stdlib.h>
struct Node {
	int data;
	struct Node* next; //定义后驱节点
	struct Node* prev; //定义前驱节点
};
struct Node* head; //定义指向头节点的的指针
struct Node* GetNewNode(int x)  //定义节点块
{
	struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
	newNode->next = NULL;
	newNode->prev = NULL;
	newNode->data = x;
	return newNode;
}  
void InsertAtHead(int x)
{
	struct Node* temp = GetNewNode(x);
	if (head == NULL)
	{
		head = temp;
		return;
	}
	head->prev = temp;  //将当前节点设为头节点的前驱节点
	temp->next = head;  //将前驱节点设为当前节点的后驱节点
	head = temp;  //将当前节点设置为头节点
}
void Print() //迭代正序打印链表  与单链表相同
{
	struct Node* temp = head;
	printf("正序列表是：");
	while (temp != NULL)  //遍历链表
	{
		printf("%d", temp->data);
		temp = temp->next;  //往下走
	}
	printf("\n");

}
void ReversePrint() //迭代逆序打印链表 
{
	struct Node* temp = head;
	if (temp == NULL)
		return;
	while (temp->next!= NULL) //先定位到最后一个节点
	{
		temp = temp->next;
	}
	printf("逆序列表是：");
	while (temp != NULL)  //从后往前遍历链表
	{
		printf("%d", temp->data);
		temp = temp->prev;  //往前走
	}
	printf("\n");
}
int main() 
{
	head = NULL;
	InsertAtHead(2); Print(); ReversePrint();
	InsertAtHead(3); Print(); ReversePrint();
	InsertAtHead(4); Print(); ReversePrint();
}