c语言 单向链表归并排序,单链表的冒泡，快排，选择，插入，归并等多图详解...

/*交换相邻节点*/

void Swanext(Node *p,Node *q)

{

/*中间相邻节点*/

if ((p != head)&&(q != head))

{

///*p为前一个节点，q的前驱为p*/

///*寻找p的前驱结点*/

// Node *ppre = FindPreNode(p);

// Node *temp;

///*暂存p节点的后继结点，指向q*/

// temp = p->next;

///*将q节点的后继节点赋值给p的后继结点，即将p节点放到了q位置(此时q的前驱节点的next指针还指向的是q)*/

// p->next = q->next;

///*将p节点给q的next，即将完成了q与p的重新连接*/

// q->next =p;

///*找到原来p的前驱节点，指向q，即完成了原来p的前驱结点和q节点的连接*/

// ppre->next =q;

if (p->next == q)

{

Node *ppre = FindPreNode(p);

p->next = q->next;

q->next = p;

ppre->next = q;

// PrintList(head);

}

else if (q->next == p)

{

Node *qpre = FindPreNode(q);

q->next = p->next;

p->next = q;

qpre->next = p;

}

}

/*头结点相邻的交换*/

else

{

if(p == head)

{

p->next = q->next;

q->next = p;

head = q;

}

else

{

q->next = p->next;

p->next = q;

head = p;

}

}

}

/*交换头结点和任意节点(除尾节点外)*/

void SwapHeadAnother(Node *tmphead,Node *p)

{

/*寻找p的前驱节点*/

Node *ppre = FindPreNode(p);

Node *temp;

if(p!=tmphead->next)

{

/*暂存p节点*/

temp = p->next;

/*将tmphead节点的后继节点赋值给p的后继结点，即将tmphead节点放到了p位置(此时p的前驱节点的next指针还未断开)*/

p->next = tmphead->next;

/*将p的后继结点赋值给tmphead的后继结点，同时连接p的前驱和tmphead*/

tmphead->next = temp;

ppre->next =tmphead;

/*新的头结点返回给全局head*/

head = p;

}

else

{

/*头结点和下一节点*/

tmphead->next = p->next;

p->next = tmphead;

head = p;

}

}

/*交换尾结点和任意节点(除头节点外)*/

void SwapEndAnother(Node *tmpend,Node *p)

{

/*寻找p的前驱节点*/

Node *ppre = FindPreNode(p);

Node *endpre = FindPreNode(tmpend);

Node *temp;

if((tmpend==end)&&(p!=tmpend))

{

/*暂存p节点*/

temp = p->next;

/*将tmpend节点的后继节点赋值给p的后继结点，即将tmpend节点放到了p位置(此时p的前驱节点的next指针还未断开)*/

p->next = tmpend->next;

endpre->next = p;

/*将p的后继结点赋值给tmpend的后继结点，同时连接p的前驱和tmpend(断开了之前的连接)*/

tmpend->next = temp;

ppre->next =tmpend;

/*新的头结点返回给全局head*/

end = p;

}

else

{

p->next = tmpend->next;

tmpend->next = p;

end = p;

}

}

/*交换头结点和尾节点*/

void SwapHeadEnd(Node *tmphead,Node *tmpend)

{

/*寻找tmpend的前驱节点*/

Node *endpre = FindPreNode(tmpend);

Node *temp;

/*暂存tmpend节点*/

temp = tmpend->next;

/*将tmphead节点的后继节点赋值给tmpend的后继结点，即将tmpend节点放到了tmphead位置(此时tmpend的前驱节点的next指针还未断开)*/

tmpend->next = tmphead->next;

/*将p的后继结点赋值给tmpend的后继结点，同时连接p的前驱和tmpend(断开了之前的连接)*/

tmphead->next = temp;

endpre->next =tmphead;

/*新的头结点返回给全局head*/

head = tmpend;

end = tmphead;

// PrintList(tmpend);

}

void SwapRandom(Node *p,Node *q)

{

/*除了首尾节点，中间不相邻的两个节点*/

if((p->next != q)||(q->next != p))

{

/*寻找前驱结点*/

Node *ppre = FindPreNode(p);

Node *qpre = FindPreNode(q);

/*借助一个中间节点传递数据域*/

Node *temp;

temp = p->next;

/*交换p和q*/

/*2、p的新后继结点要变成q的原后继结点*/

p->next = q->next;

/*3、q的原前趋结点(qpre)的新后继结点要变成p*/

qpre->next = p;

/*4、q的新后继结点要变成p的原后继结点(p->next)*/

q->next = temp;

/*1、p的原前趋结点(ppre)的新后继结点要变成q*/

ppre->next = q;

}

/*中间相邻节点的处理*/

else if (p->next == q)

{

Node *ppre = FindPreNode(p);

p->next = q->next;

q->next = p;

ppre->next = q;

}

else if (q->next == p)

{

Node *qpre = FindPreNode(q);

q->next = p->next;

p->next = q;

qpre->next = p;

}

}

/*交换任意两个节点*/

void SwapNode(Node*p, Node*q)

{

// if(LengthList(head)<2)

// printf("Can not swap!The Length of list is:%d\r\n ",LengthList(head));

/*检查是否是头尾节点*/

/*对于头尾节点有四种情况

*1.p头节点和q为中间节点

*2.p尾节点和q为中间节点

*3.q头节点和p为中间节点

*4.q尾节点和p为中间节点

*5.p头结点和q尾节点

*6.q头结点和p尾节点

*7.其他中间交换的情况

*/

/*2.两个节点是否相邻 除去头结点和下一节点相邻的情况，放在headanother处理*/

if((p->next == q)&&(p !=head)&&(q !=head))

Swanext(p,q);

else if((q->next == p)&&(p !=head)&&(q !=head))

Swanext(q,p);

/*1.p头节点和q为中间节点*/

else if((p == head)&&(q != end))

SwapHeadAnother(p,q);

/*2.p尾节点和q为中间节点*/

else if ((p == end)&&(q != head))

SwapEndAnother(p,q);

/*3.q头节点和p为中间节点*/

else if((q == head)&&(p != end))

SwapHeadAnother(q,p);

/*4.q尾节点和p为中间节点*/

else if((q == end)&&(p != head))

SwapEndAnother(q,p);

/*5.p头结点和q尾节点*/

else if((p == head)&&(q == end))

SwapHeadEnd(p,q);

/*6.q头结点和p尾节点*/

else if((q == head)&&(p == end))

SwapHeadEnd(q,p);

/*7.其他中间交换的情况*/

else

SwapRandom(p,q);

}