单向链表

 1 PT_LNode creadNode()        //创建节点
 2 {
 3     PT_LNode pNew = (PT_LNode)malloc(sizeof(T_LINKNODE));
 4     init(pNew);
 5     return pNew;
 6 }
 7 
 8 void init(PT_LNode pHead)    //初始化
 9 {
10     pHead->data = 0;
11     pHead->pNext = NULL;
12 }

 1 int insertHead(PT_LNode pHead, int data) //头插 头节点计数
 2 {
 3 　　if (isEmpty(pHead))
 4　　 {
 5 　　　　insertBack(pHead, data);
 6 　　　　return ++(pHead->data);
 7 　　}
 8 　　else
 9 　　{
10　　　　 PT_LNode pNew = creadNode();
11　　　　 pNew->data = data;
12　　　　 pNew->pNext = pHead->pNext;
13 　　　　pHead->pNext = pNew;
14 　　　　return ++(pHead->data);
15 　　}
16 }

 1 int insertBack(PT_LNode pHead, int data) //尾插 头节点计数
 2 {
 3 　　PT_LNode p = pHead;
 4 　　while (p->pNext)
 5 　　{
 6　　　　 p = p->pNext;
 7 　　}
 8　　 PT_LNode pNew = creadNode();
 9 　　pNew->data = data;
10 　　p->pNext = pNew;
11 　　return ++(pHead->data);
12 }

 1 int insertNode(PT_LNode pHead, int Fdata, int newData)        
 2 {
 3     
 4     PT_LNode tempNode = findData(pHead, Fdata);      //findData在下面
 5 
 6     PT_LNode pNew = creadNode();
 7     pNew->data = newData;
 8     if ((!tempNode->pNext) && (tempNode->data  == Fdata))
 9     {
10         insertBack(pHead, newData);
11     }
12     else
13     {
14         pNew->pNext = tempNode->pNext;
15         tempNode->pNext = pNew;
16         return ++(pHead->data);
17     }
18 }

 1 int deleteHead(PT_LNode pHead)
 2 {
 3 　　int temp;
 4 　　PT_LNode p = pHead->pNext;
 5　　 pHead->pNext = p->pNext;
 6 　　temp = p->data;
 7 　　free(p);
 8 　　p = NULL;
 9 　　--pHead->data;
10 　　return temp;    
11 }

 1 int deleteBack(PT_LNode pHead)
 2 {
 3 　　int temp;
 4 　　PT_LNode p = pHead; 
 5 　　while (p->pNext->pNext)
 6　　 { 
 7 　　　　p = p->pNext;
 8 　　}
 9 　　temp = p->pNext->data;
10　　 free(p->pNext);
11 　　p->pNext = NULL;
12 　　--pHead->data;
13 　　return temp;
14 }

 1 int temp;
 2 PT_LNode p = pHead->pNext;
 3 while (p->pNext)
 4 {
 5 if (p->pNext->data == deleteData)
 6 {
 7 　　break;
 8 }
 9 　　p = p->pNext;
10 }
11 if ((!p->pNext) && (p->data == deleteData))
12 {
13 　　deleteBack(pHead);
14 }
15 else if ( p == pHead->pNext && p->data == deleteData)
16 {
17 　　deleteHead(pHead);
18 }
19 else
20 {
21 　　PT_LNode pTemp = p->pNext;
22 　　p->pNext = pTemp->pNext;
23 　　temp = pTemp->data;
24 　　free(pTemp);
25 　　pTemp->pNext = NULL;
26 　　--pHead->data;
27 　　return temp;
28 }

 1 PT_LNode findData(PT_LNode pHead, int Fdata)    //返回要查找数据的指针
 2 {
 3     PT_LNode p = pHead;
 4     bool flag = true;
 5     while (p->pNext)
 6     {
 7         if (p->data == Fdata)
 8         {
 9             break;
10         }
11         else
12         {
13             p = p->pNext;
14         }
15     }
16     (!p->pNext) && (p->data != Fdata) ? flag = false : flag;
17     if (flag)
18     {
19         printf("要查找的数据存在\n");
20         return p;
21     }
22     else
23     {
24         printf("要查找的数据不存在\n");
25         return NULL;
26     }
27 }

 1 void changeData(PT_LNode pHead, int Fdata, int newData)
 2 {
 3     PT_LNode pTemp = findData(pHead, Fdata);
 4     if (!pTemp)
 5     {
 6         printf("数据不存在\n");
 7         return ;
 8     }
 9     else
10     {
11         pTemp->data = newData;
12     }
13 }

1 void reversalPrint(PT_LNode pHead)
2 {
3     if (!pHead)
4     {
5         return;
6     }
7     reversalPrint(pHead->pNext);
8     printf("%d<-", pHead->data);
9 }

 1 PT_LNode reversalList(PT_LNode pHead)
 2 {
 3     if (!pHead->pNext || !pHead)
 4     {
 5         return pHead;    
 6 
 7     }　　　　
 8     PT_LNode pTemp = reversalList(pHead->pNext);　　//传入当前节点pHead进入递归 并 另存当前节点
 9     pHead->pNext->pNext = pHead;　　　　　　　　　　　//当前节点指向上一个节点
10     pHead->pNext = NULL;　　　　　　　　　　　　　　　　//把上一个节点制空
11     return pTemp;　　　　　　　　　　　　　　　　　　　　//返回当前节点 , 用作上一层递归
12 }

 1 bool judgeCircle(PT_LNode pHead)
 2 {
 3     PT_LNode p1, p2;
 4     p1 = pHead;    p2 = pHead;
 5     while (p1->pNext && p2->pNext)
 6     {
 7         
 8         p2 = p2->pNext;
 9         p1 = p1->pNext->pNext;
10         if (p1 == p2)
11         {
12             return true;
13         }
14     }
15     return false;
16 }

 1 PT_LNode mergeList(PT_LNode pHead3, PT_LNode pHead1, PT_LNode pHead2)
 2 {
 3     PT_LNode p1 = pHead1;
 4     PT_LNode p2 = pHead2;
 5     while (p1 || p2)　　　　//必须两个链表都遍历完
 6     {
 7         if (p1 && p2)　　　　
 8         {
 9             if (p1->data < p2->data)　　//1对1 2对2 彼此对应比较 较小的放前面
10             {
11                 insertBack(pHead3, p1->data);
12                 p1 = p1->pNext;
13             }
14             else
15             {
16                 insertBack(pHead3, p2->data);
17                 p2 = p2->pNext;
18             }
19         }
20         else　　　　　　　　//链表节点数量不相同 , 则把后面的都插入 , 因为是链表已经是有序的 , 前面比较都是比后面的小 , 所以剩余的节点全部依次插入新链表
21         {
22             while (p1)
23             {
24                 insertBack(pHead3, p1->data);
25                 p1 = p1->pNext;
26             }
27             while (p2)
28             {
29                 insertBack(pHead3, p2->data);
30                 p2 = p2->pNext;
31             }
32             break;　　　　　　//链表遍历完成 退出遍历
33         }
34     }
35     return pHead3;　　　　//返回新链表
36 }

 1 void ListSort(PT_LNode pHead)
 2 {
 3     PT_LNode p1, p2;
 4     int temp;
 5     for (p1 = pHead->pNext; p1->pNext; p1 = p1->pNext)
 6     {
 7         for (p2 = p1->pNext; p2; p2 = p2->pNext)
 8         {
 9             if (p1->data > p2->data)
10             {
11                 temp = p1->data;
12                 p1->data = p2->data;
13                 p2->data = temp;
14             }
15         }
16     }
17 }