单链表的各种基本操作（C/C++版）

代码可以直接运行，参考的是王道数据结构线性表的链式表示这一节

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

//定义单链表结构体 
typedef struct LNode{
	int data;	//数据域 
	struct LNode *next;//指针域 
}LNode,*LinkList;

//本程序默认使用带头结点的单链表 

//初始化链表
void InitLinkList(LinkList &L){
	L=(LinkList)malloc(sizeof(LNode));
	L->next=NULL;
} 

//头插法创建单链表 创建出来的是逆序 
void  List_HeadCreate(LinkList &L){
	LNode *s;
	int x;
	L=(LinkList)malloc(sizeof(LNode));//创建头节点并分配内存空间
	L->next=NULL;
	scanf("%d",&x);
	while(x!=9999){
		s=(LNode *)malloc(sizeof(LNode));
		s->data=x;
		s->next=L->next;
		L->next=s;
		scanf("%d",&x);
	} 
}

//尾插法创建单链表  创建出来是顺序的 
void List_TailCreate(LinkList &L){
	L=(LinkList)malloc(sizeof(LNode));
	L->next=NULL;
	LNode *p=L,*s;
	int x;
	scanf("%d",&x);
	while(x!=9999){
		s=(LNode *)malloc(sizeof(LNode));
		s->data=x;
		p->next=s;
		p=s;
		scanf("%d",&x);
	}
	p->next=NULL;
}

//单链表遍历打印 
void Print(LinkList head){
	LNode *p=head;
	while(p->next!=NULL){
		printf("%d  ",p->next->data);
		p=p->next;
	}
	printf("\n");
}

//逆序打印链表  此时head是不带头结点的单链表打印才能完全正确 
void rePrint(LinkList head){
	if(head!=NULL){
		rePrint(head->next);
		printf("%d  ",head->data);
	}
} 

//链表长度
int ListLength(LinkList L){
	int i=0;
	LNode *p=L->next;
	while(p!=NULL){
		i++;
		p=p->next;
	}
	
	return i;
} 

//按序号查找单链表的节点
LNode *GetElem(LinkList L,int n){
	if(n>ListLength(L)||n<=0){
		printf("序号与长度不匹配，无法查找\n");
		return NULL;
	}
	int i=1;
	LNode *p=L->next;
	while(p!=NULL){
		if(i==n)
			return p;
		i++;
		p=p->next;
	}
	return NULL;
} 

//按值查找单链表的节点
LNode *LocateElem(LinkList L,int data){
	LNode *p=L->next;
	while(p!=NULL){
		if(p->data==data)
			return p;
		p=p->next;
	}
	printf("未找到\n");
	return NULL;
}

//插入节点 
//number:在第几个位置插入节点  data：要插入节点的数据 
void InsertLNode(LinkList &L,int number,int data){
	if(number>ListLength(L)||number<=0){
		printf("插入失败\n");
		return ;	
	}
	
	LNode *p=GetElem(L,number-1);//获取该序号的前一个序号
	LNode *s=(LNode *)malloc(sizeof(LNode));
	s->data=data;
	s->next=p->next;
	p->next=s; 
}

//在链表尾部插入节点 尾插法 
void InsertLNodeTail(LinkList &L,int data){
	LNode *s=(LNode *)malloc(sizeof(LNode));
	s->data=data;
	LNode *p=L->next;
	while(p->next!=NULL)
		p=p->next;
	p->next=s;
	p=s;
	p->next=NULL; 
} 

//在链表首部插入节点 头插法 
 void InsertLNodeHead(LinkList &L,int data){
 	LNode *s=(LNode *)malloc(sizeof(LNode));
 	s->data=data;
 	s->next=L->next;
	L->next=s; 
 }

//根据值删除单链表中的节点 
void List_DeleteElemByElem (LinkList &L,int data){
	LNode *p=L->next;
	while(p->next!=NULL){
		if(p->next->data==data){
			LNode *s=p->next;
			p->next=s->next;
			free(s);
			return;
		}
		p=p->next;
	}
	
}

//根据序号删除单链表的节点 
void List_DeleteElemByNode(LinkList &L,int i){
	LNode *p=GetElem(L,i-1);//获取要删除结点的前一个结点
	LNode *s=p->next;
	p->next=s->next;
	free(s); 
}

//单链表进行快速排序
void swap(LNode* p, LNode* q)
{
	int temp = p->data;
	p->data = q->data;
	q->data = temp;
}

void QuickSort(LinkList &head, LinkList &end)
{
	if (head == NULL||head->next==NULL||head==end)
		return;


	int pivot = head->data;
	LNode* i_pre = head;//指向i的前一个结点
	LNode* i = head->next;
	LNode* j = head->next;

	while (j != end->next)
	{
		if (j->data < pivot)
		{
			//交换i节点与j节点的值
			swap(i, j);

			i_pre = i;
			i = i->next;
		}

		j = j->next;
	}

	//交换pivot与i_pre的值
	swap(head, i_pre);

	QuickSort(head, i_pre);
	QuickSort(i, end);
}


int main(){
	
	LinkList s;
	
	//尾插法创建单链表 
//	List_HeadCreate(s);
	
	//头插法创建单链表 
	List_TailCreate(s);
	
	//遍历输出链表 
	Print(s);
	
	//按值查找结点 
	LNode *p=LocateElem(s,4);
	if(p!=NULL)
		printf("%d\n",p->data);
		
	
	//链表长度
//	printf("链表长:%d\n",ListLength(s)); 

	//按序号查找结点
	p=GetElem(s,4);
	if(p!=NULL)
		printf("%d\n",p->data); 
		
	//链表首部插入一个节点 
//	InsertLNodeHead(s,5);
	
	//链表尾部插入一个节点
//	InsertLNodeTail(s,0); 

	//指定在第几个元素插入节点
	InsertLNode(s,3,8); 
	
	//遍历链表 
//	rePrint(s->next);

	//根据值删除节点
//	List_DeleteElemByElem(s,5); 

	//根据序号删除节点
	List_DeleteElemByNode(s,4); 

	//遍历输出链表 
	Print(s);
	
	return 0;
}