有一个带头结点的单链表L，设计一个算法使其元素递增

算法思想：

//其实可以和数组的对比起来，数组就是通过冒泡、选择、插入、快速，归并排序常见的排序来排，但是这里是链表 // 不能直接像数组那样在原有的链表上面进行排序，链表通常是有两种初始化方式，头插法，尾插法，头插法就是和原有的链表逆置，尾插和原有相同 

LinkList Sort(LinkList &L){
         //1.直接插入排序
         Lnode *p=L->next,*pre;
         Lnode *r=p->next;//r作为p放入后继，防止断链
         p->next=NULL;//构造只有一个数据结点的有序表
         p=r;
         while(p!=NULL){
             r=p->next;
             pre=L;
             while(pre->next!=NULL&&pre->next->data<p->data){
                 pre=pre->next;             
             }
              p->next=pre->next;
              pre->next=p;
              p=r;        
         }
}

当然还可转化为数组来进行排序后，再放入链表，数组常见的排序就是冒泡，选择，插入，快速，还有堆排序，桶排序等等，选择法、冒泡法、交换法、插入法、折半法。这里先给出一种为了成功排序的，我这里使用的冒泡排序

后面会继续更新其他8大类排序，最优的就是 快速归并以及桶排序O(nlog2n），堆排序，当然这里指的是时间复杂度，有些排序不稳定，其他常见的排序就是O(n²)

下面给出这里链表转数组的代码

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100000
typedef struct Lnode{
	int data;//数据域 
	struct Lnode *next;//指针域 
}Lnode,*LinkList;
int a[5]={8,2,3,4,5};
int n=5;
int b[MAXSIZE],t=0;
//这里使用尾插法，把数据放在L中 
void InitList(LinkList &L,int t[]){
	L=(LinkList)malloc(sizeof(Lnode));
	Lnode *s,*r=L;//r为尾指针 
//	r->data=a[0];  //这里必须设置r指向数组a中一个元素，否则直接输出会多一个初始值为0的情况 
//	if(n==1) r->next=NULL;
    
	        for(int i=0;i<n;i++){
			s=(Lnode *)malloc(sizeof(Lnode));//为指针s分配空间初始化 
			s->data=t[i];
			r->next=s;
			r=r->next;//	更新r的位置，始终指向最后一个元素，也可使用
			//r=s代替，同样是更新r的位置 
		 
	}
	//依次添加完了，要把下r->next必须指向空 
	r->next=NULL;
	
} 
void PrintList(LinkList L){
	Lnode *s=L->next;
	while(s){
		printf("%d	 ",s->data );
		s=s->next;  
	}
	printf("\n");
} 
 
 void printArrays(int a[],int len){
 	for(int i=0;i<len;i++){
 		printf("%d ",a[i]);
	 }
	 printf("\n");
 }
 //数组冒泡排序 
void sort(int a[],int t){
	int temp;
	for(int i = 0;i < n;i++)
	{
		for(int j = n-1;j > i;j--)
		{
			if(a[j] < a[j-1])
			{
				temp = a[j];
				a[j] = a[j-1];
				a[j-1] = temp;
			}
		}
	}
} 
void Del_x(LinkList &L,int x){
	Lnode *p=L->next,*pre=L,*q;//这里声明一个P节点指向L的下一个，pre为P节点的前驱节点
	while(p!=NULL){
		if(p->data==x){
			//这里相等就把q指向p 
			q=p; 
			p=p->next;
			pre->next=p;//这上面三步操作就是把q指向p,p指向下一个，p的前驱节点pre的下一个节点指向p 
			free(q);//释放q 
		}else{//不等于p和pre同步后移
		pre=p;
		p=p->next; 
		}
	} 

} 
int main(){
 	Lnode list;
 
	Lnode *L=&list;
//	Lnode *L;//指针初始化和引用	 
	InitList(L,a); 
	//PrintList(L);
    printArray(L);
    sort(b,t);
    printf("\n");
    printArrays(b,t);
    InitList(L,b);
	PrintList(L);
	//printArray(b,6);
	  
//	Del_x(L,2);
//	PrintList(L);
	return 0;
} 

之后会详细介绍给个排序的优缺点以及如何选择排序的方式！