单双链表的操作

单链表查找删除-双链表插入删除包括按值查找，按序号查找，删除指定位置的元素。

按序号查找

先检查要查询位置是否合法，要查询位置为0，即为头结点；如果位置小于0，即查询不到，如果合法开始查询，先使用一个指针指向第一个结点，然后逐个查找。

按值查找

先使用一个指针指向第一个结点，依次查找，直到找到。

删除指定位置的元素

改链表不需要引用，只需要把链表的地址值传入，只有修改L的值也就是头结点的地址值才需要引用。
先使用一个指针指向要删除元素的前一个结点，判断是否为空，不为空则可以执行删除操作，接着再使用一个指针指向要删除位置的结点，将要删除位置结点的指针域赋给要删除位置前一个结点的指针域，释放删除位置结点，最后将指针置为0。

//单链表
#include
#include

typedef int ElemType;
typedef struct LNode {
	ElemType data;
	struct LNode* next;
}LNode,*LinkList;
void PrintList(LinkList L)

{

	L = L->next;

	while (L != NULL)

	{

		printf("%d", L->data);//打印当前结点数据

		L = L->next;//指向下一个结点

		if (L != NULL)

		{

			printf(" ");

		}

	}

	printf("\n");

}
LinkList CreateList1(LinkList& L) {
	L = (LinkList)malloc(sizeof(LNode));//创建头结点
	L->next = NULL;//头结点的指针域为空
	LinkList s; int x;
	scanf("%d", &x);//读入数据
	while (x != 9999) {
		s = (LinkList)malloc(sizeof(LNode));//创建结点
		s->data = x;//向创建好的结点中存入数据
		s->next = L->next;//插入数据
		L->next = s;
		scanf("%d", &x);
	}
	return L;
}
LinkList CreateList2(LinkList& L) {
	L = (LinkList)malloc(sizeof(LNode));//创建头结点
	L->next = NULL;//头结点的指针域为空
	LinkList s=NULL,r=L; int x;
	scanf("%d", &x);//读入数据
	while (x != 9999) {
		s = (LinkList)malloc(sizeof(LNode));//创建结点
		s->data = x;//向创建好的结点中存入数据
		r->next = s;//插入操作
		r = s;
		scanf("%d", &x);
	}
	r->next = NULL;//将最后一个结点的指针域置为空
	return L;
}
LinkList GetElem(LinkList L, int i) {
	int j = 1;
	LinkList p = L->next;
	if (0 == i) {
		return L;
	}
	if (i < 1) {
		return NULL;
	}
	while (p && j < i) {
		p = p->next;
		j++;
	}
	return p;
}
LinkList LocateElem(LinkList L, ElemType e) {
	LinkList p = L->next;
	while (p != NULL && p->data != e) {
		p = p->next;
	}
	return p;
}
bool ListFrontInsert(LinkList L, int i, ElemType e) {
	LinkList p = GetElem(L,i - 1);
	if (p == NULL) {
		return false;
	}
	LinkList s = (LinkList)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}
bool ListDelete(LinkList L,int i) {
	//改链表不需要引用，只需要把链表的地址值传入，只有修改L的值也就是头结点的地址值才需要引用
	LinkList p = GetElem(L, i - 1);
	if (NULL == p) {
		return false;
	}
	LinkList q = p->next;
	p->next = q->next;
	free(q);
	q = NULL;
	return true;
}

int main() {
	LinkList L;//创建一个头指针
	//头插法
	/*CreateList1(L);
	PrintList(L);*/
	//尾插法
	CreateList2(L);
	PrintList(L);
	LinkList search;
	//按序号查询
	search = GetElem(L, 2);
	if (search != NULL) {
		printf("按序号查找成功\n");
		printf("%d\n", search->data);
	}
	//按值查询
	search = LocateElem(L, 6);
	if (search != NULL) {
		printf("按值查找成功\n");
		printf("%d\n", search->data);
	}
	ListFrontInsert(L, 2, 99);
	PrintList(L);
	//删除操作
	ListDelete(L, 4);
	PrintList(L);
	return 0;
}

单链表不能向前遍历，只能先后遍历；而双向链表可以。
双链表的插入操作：

//从前先后操作
s->next=p->next;
p->next-prior=s;//头结点后面没有结点时不需要此步
s->prior=p;
p->next=s;

源代码

#include
#include

typedef int ElemType;
typedef struct DNode {
	ElemType data;
	struct DNode* prior;//前驱
	struct DNode* next;//后继
}DNode,*DLinkList;
void PrintDList(DLinkList DL) {
	DL = DL->next;
	while (DL != NULL) {
		printf("%3d", DL->data);
		DL = DL->next;
	}
	printf("\n");
}
DLinkList Dlist_head_insert(DLinkList& DL) {
	DNode* s; int x;
	DL = (DLinkList)malloc(sizeof(DNode));
	DL->next = NULL;
	DL->prior = NULL;
	scanf("%d", &x);
	while (x != 9999) {
		s = (DLinkList)malloc(sizeof(DNode));
		s->data = x;
		s->next = DL->next;
		if (DL->next != NULL) {
			DL->next->prior = s;
		}
		s->prior = DL;
		DL->next = s;
		scanf("%d", &x);
	}
	return DL;
}
DLinkList Dlist_tail_insert(DLinkList& DL) {
	int x;
	DL = (DLinkList)malloc(sizeof(DNode));
	DNode* s, * r=DL;
	DL->prior = NULL;
	scanf("%d", &x);
	while (x != 9999) {
		s = (DLinkList)malloc(sizeof(DNode));
		s->data = x;
		r->next = s;
		s->prior = r;
		r = s;
		scanf("%d", &x);
	}
	r->next = NULL;
	return DL;
}
DLinkList GetElem(DLinkList DL, int i) {
	int j = 1;
	DLinkList p = DL->next;
	if (i == 0) {
		return DL;
	}
	if (i < 1) {
		return NULL;
	}
	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}
	return p;
}
bool DListFrontInsert(DLinkList DL, int i, ElemType e) {
	DLinkList p = GetElem(DL, i - 1);
	if (p == NULL) {
		return false;
	}
	DLinkList s = (DLinkList)malloc(sizeof(DNode));
	s->data = e;
	s->next = p->next;
	p->next->prior = s;
	s->prior = p;
	p->next = s;
	return true;
}
bool DListDelete(DLinkList DL, int i) {
	DLinkList p = GetElem(DL, i - 1);
	if (p == NULL) {
		return false;
	}
	DLinkList q ;
	q = p->next;
	if (q == NULL) {
		return false;
	}
	p->next = q->next;
	if (q->next != NULL) {
		q->next->prior = p;
	}
	free(q);
	return true;
}
int main() {
	DLinkList DL;
	/*Dlist_head_insert(DL);*///3 4 5 6 7 9999
	Dlist_tail_insert(DL);
	/*DLinkList search;
	search = GetElem(DL, 2);
	printf("查找的元素为:%d\n", search->data);*/
	DListFrontInsert(DL, 3, 99);
	PrintDList(DL);
	return 0;
}