单链表操作

这篇文章的目的只是为了自己复习单链表而写，里面的代码没有经过实际测试。只是好让自己保持思路。

1. 删除链表节点

   /* 单链表删除节点 */
   Node *del(Node *head, int num)
   {
   	Node *p1, *p2;
   	p1 = head;
   	//先找到要删除的节点，再去判断其位置
   	while(num != p1->data || p1->next != NULL){
   		p2 = p1;
   		p1 = p1->next; //p1在前，p2在后
   	}
   
   	if(num == p1->data){
   		if(p1 == head){ //判断结点位置是否为头
   			head = p1->next;
   		}
   		else {
   			p2->next = p1->next;
   		}
   		free(p1);
   	}
   
   	return head;
   }

   
   
2. 单链表插入节点（从小到大顺序）

   /* 插入链表节点, 按从小到大的顺序插 */
   Node *insert(Node *head, int num)
   {
   	Node *p0, *p1, *p2;
   	p1 = head;
   	p0 = (Node *)malloc(sizeof(Node));
   	p0->data = num;
   	while(p0->data > p1->data && p1->next != NULL){
   		p2 = p1;
   		p0 = p0->next;
   	}
   	
   	if(p0->data > p1->data){
   		if(p1 == head) { //插入表头
   			p0->next = p1;
   			head = p0;
   		}
   		else { //插入中间
   			p0->next = p2->next;
   			p2->next = p0;
   		}
   	}
   	else { //插入链表尾
   		p1->next = p0;
   		p0->next = NULL;
   	}
   	return head;
   }

   
   
3. 单链表排序，使用冒泡法

   Node *sort(Node *head)
   {
   	Node *p0, *p1;
   	int n = 0;
   	int temp;
   
   	p0 = head;
   	while(p0){
   		p0 = p0->next;
   		n++;
   	}
   
   	for(int i = 1; i < n; i++){
   		p1 = head;
   		for(int j = n-1; j > i; j--){
   			p0 = p1->next;
   
   			if(p0->data > p1->data){
   				temp = p1->data; //临时保存
   				p1->data = p0->data;
   				p1->next = p0->next;
   				p0->next = p1;
   				p0->data = temp
   			}
   			p0 = p0->next;
   		}
   	}
   	return head;
   }

   
   
4. 单链表逆置

   Node *reverse(Node *head)
   {
   	Node *p0, *p1, *p2;
   
   	if(head == NULL || head->next = NULL)
   		return head;
   
   	p2 = head;
   	p1 = p2->next;
   	
   	while(p1){
   		p0 = p1->next;
   		p1->next = p2; //p2->next下一次循环处理
   		p2 = p1;
   		p1 = p0;
   	}
   
   	head->next = NULL;
   	p0->next = p1;
   	head = p0;
   	return head;
   }