链表高级算法--1

一、链表选择排序

[cpp]  view plain  copy

 

1. void SelectSort(pLinkList list)                  //选择排序  
2. {  
3.     assert(list);  
4.     if (NULL == list->pHead || NULL ==list->pHead->next)  //如果是空链表或者只有一个结点则直接结束  
5.     {  
6.         return;  
7.     }  
8.     pLinkNode cur = list->pHead;  
9.     pLinkNode p = NULL;  
10.     pLinkNode min = NULL;  
11.     while (cur!=NULL)  
12.     {  
13.         p = cur->next ;               //p指向无序区第二个元素  
14.         min = cur;                    //min指向无序区第一个元素  
15.         while (p != NULL)  
16.         {  
17.             if (min->data > p->data)  
18.             {  
19.                 min = p;             //min记录最小的data的地址  
20.             }  
21.             p = p->next;  
22.         }  
23.         if (min != cur)              //将min所指向的data与无序区第一个元素进行交换  
24.         {  
25.             DataType tmp = cur->data;  
26.             cur->data = min->data;  
27.             min->data = tmp;  
28.         }  
29.         cur = cur->next;              //有序区加一，无序区减一  
30.     }  
31. }  

二、寻找中间结点

  快慢指针是解决大多数链表问题的一个重要方法，在本题中就应用到了快慢指针，快指针fast每次走两步，慢指针slow每次走一步，等到fast走到链表尾部时，slow刚好指向中间结点。

[cpp]  view plain  copy

 

1. pLinkNode FindMindNode(pLinkList list)          //查找中间节点  
2. {  
3.     assert(list);  
4.     pLinkNode fast= list->pHead;                //快指针，每次走两步  
5.     pLinkNode slow = list->pHead;               //慢指针，每次走一步  
6.     while (NULL!=fast)  
7.     {  
8.         if (NULL != fast->next)                  //如果fast不是尾结点  
9.         {  
10.             fast = fast->next->next;  
11.             slow = slow->next;  
12.         }  
13.         else  
14.         {  
15.             break;  
16.         }  
17.     }  
18.     return slow;  
19. }  

三、删除一个非尾的结点

[cpp]  view plain  copy

 

1. void EraseNotTail(pLinkNode pos)                 //删除非尾结点  
2. {  
3.     assert(pos->next);  
4.     pLinkNode cur = pos->next;  
5.     pos->data = cur->data;  
6.     pos->next = cur->next;  
7.     free(cur);  
8.     cur = NULL;  
9. }  

四、删除倒数第k个结点，k大于1，小于链表长度（O（n））

   这个题跟快慢指针很像，我们可以先让一个指针走k步，然后再让一个指针从起点出发,等到先走的指针到达链表尾部时，第二个指针刚好指向倒数第k个结点。

[cpp]  view plain  copy

 

1. void DelKnode(pLinkList list,int k)                    //删除倒数第k个结点，k要大于1，小于链表长度   
2. {  
3.     assert(list);  
4.     if (NULL == list->pHead || NULL == list->pHead->next||k<=1)  
5.     {  
6.         return;  
7.     }  
8.     pLinkNode cur = list->pHead;  
9.     pLinkNode del= list->pHead;                 //del指向要删除的结点  
10.     while (cur->next!=NULL)  
11.     {  
12.         k--;                                    //cur先走k步，del再开始走  
13.         if (k <=0)  
14.         {  
15.             del = del->next;  
16.         }  
17.         cur = cur->next;  
18.     }  
19.     if (k <=0)  
20.     {  
21.         del->data = del->next->data;          //del的下一个结点的data保存到del里面  
22.         cur = del->next;                      //记住del下一个结点的地址  
23.         del->next = cur->next;                //del指向del的下下一个结点  
24.         free(cur);                            
25.         cur = NULL;  
26.     }  
27. }  

五、反转链表

[cpp]  view plain  copy

 

1. void Reverselist(pLinkList list)                   //反转链表  
2. {  
3.     assert(list);  
4.     if (NULL == list->pHead || NULL == list->pHead->next)  
5.     {  
6.         return;  
7.     }  
8.     pLinkNode newHead = NULL;           //指向新链表的头  
9.     pLinkNode tmp = NULL;  
10.     pLinkNode cur = list->pHead;  
11.     while (cur != NULL)  
12.     {  
13.         tmp = cur->next;                 //tmp保存cur的下一个结点  
14.         cur->next = newHead;             //指向新链表的头  
15.         newHead = cur;                   //链表的头指针移动  
16.         cur = tmp;                       //cur指向下一个结点  
17.     }  
18.     list->pHead = newHead;  
19. }  

六、在指定位置结点的前面插入一个结点

   这个问题与删除一个非尾结点是一模一样的解决方法！！！

[cpp]  view plain  copy

 

1. void InsertFrontNode(pLinkNode pos, DataType x)     //在当前结点前插入一个结点  
2. {  
3.     assert(pos);  
4.     pLinkNode newNode=NULL;  
5.     newNode = (pLinkNode)malloc(sizeof(LinkNode));       //创建一个新结点  
6.     if (NULL ==newNode)  
7.     {  
8.         printf("out of memory\n");  
9.         exit(EXIT_FAILURE);  
10.     }  
11.     newNode->next = pos->next;             //将这个新节点插入到pos后面  
12.     pos->next = newNode;  
13.     newNode->data = pos->data;             //将pos指向的data保存到newHead里面  
14.     pos->data = x;                         //将x保存在pos里面  
15. }