单链表的操作包括：创建单链表、输出单链表长度 、输出单链表、删除节点、插入节点、单链表排序、单链表逆置。虽然思路都很简单，但是真写程序类运行时就遇到各种错误。

 

 
  
  1. #include<iostream>  
  2. using namespace std;  
  3.  
  4. struct node  
  5. {  
  6.     int data;  
  7.     node *next;  
  8. };  
  9.  
  10. //建立单链表  
  11. node * creat()  
  12. {  
  13.     node *head;  
  14.     head=(node *)malloc(sizeof(node));  
  15.     node *p=head;//保存下头  
  16.     while(1)  
  17.     {     
  18.         int x;  
  19.         scanf("%d",&x);  
  20.         if(x==0)  
  21.             break;  
  22.         node *s=(node *)malloc(sizeof(node));//增加一个节点  
  23.         s->data=x;  
  24.         p->next=s;  
  25.         p=s;  
  26.           
  27.     }  
  28.     head=head->next;  
  29.     p->next=NULL;//注意结尾赋空  
  30.     return head;  
  31. }  
  32.  
  33. //求单链表长度  
  34. int length(node * head)  
  35. {  
  36.     node *p=head;  
  37.     int len=1;  
  38.     while(p->next!=NULL)  
  39.     {  
  40.         p=p->next;  
  41.         len++;  
  42.     }  
  43.     return len;  
  44. }  
  45.  
  46. //打印单链表  
  47. void print(node *head)  
  48. {  
  49.     node *p=head;  
  50.     while(p!=NULL)  
  51.     {  
  52.         printf("%d  ",p->data);  
  53.         p=p->next;  
  54.  
  55.     }  
  56.     printf("\n");  
  57. }  
  58.  
  59. //删除单链表中的某元素  
  60. node *del(node *head,int num)  
  61. {  
  62.     node *p1,*p2;  
  63.     p1=head;  
  64.     while(p1->next!=NULL)  
  65.     {  
  66.         if(p1->data==num)  
  67.             break;  
  68.         else 
  69.         {  
  70.             p2=p1;  
  71.             p1=p1->next;  
  72.         }  
  73.     }  
  74.     if(p1->data==num)  
  75.     {  
  76.         if(p1==head)  
  77.         {  
  78.             head=p1->next;  
  79.             free(p1);  
  80.         }  
  81.         else 
  82.         {  
  83.             p2->next=p1->next;  
  84.             free(p1);  
  85.         }  
  86.     }  
  87.     else 
  88.         printf("%d cannot find",num);  
  89.     return head;  
  90. }  
  91.  
  92.  
  93. //单链表插入元素   原表升序排列  
  94. node *insert(node *head,int num)  
  95. {  
  96.     node *p1,*p2;  
  97.     p1=head;  
  98.     node *in=(node *)malloc(sizeof(node));  
  99.     in->data=num;  
  100.     while(p1->next!=NULL)  
  101.     {  
  102.         if(p1->data<num)//注意无等号  
  103.         {  
  104.             p2=p1;  
  105.             p1=p1->next;  
  106.         }  
  107.         else   
  108.             break;  
  109.     }  
  110.     if(head==p1)  
  111.     {  
  112.         in->next=p1;  
  113.         head=in;  
  114.     }  
  115.     if(p1->data>=num)//注意有等号  
  116.     {  
  117.         in->next=p2->next;p2->next=in;  
  118.     }  
  119.     else 
  120.     {  
  121.         p1->next=in;  
  122.         in->next=NULL;  
  123.  
  124.     }  
  125.     return head;  
  126. }  
  127.  
  128. //单链表升序排序  
  129. node *sort(node *head)  
  130. {  
  131.     node *p=head;  
  132.     int n=length(head);  
  133.     for(int i=1;i<n;i++)//注意i从1开始  
  134.     {  
  135.         p=head;  
  136.         for(int j=0;j<n-i;j++)  
  137.         {  
  138.             if(p->data>p->next->data)  
  139.             {  
  140.                 int tmp=p->data;  
  141.                 p->data=p->next->data;  
  142.                 p->next->data=tmp;  
  143.             }  
  144.             p=p->next;  
  145.         }  
  146.     }  
  147.     return head;  
  148. }  
  149.  
  150. //单链表逆置  
  151. node *reserve(node *head)  
  152. {  
  153.     node *p1=head;  
  154.     node *p2=head->next;  
  155.     while(p2)  
  156.     {  
  157.         node *p3=p2->next;//p3存下来  
  158.         p2->next=p1;  
  159.         p1=p2;  
  160.         p2=p3;  
  161.     }  
  162.     head->next=NULL;  
  163.     head=p1;  
  164.     return head;  
  165. }  
  166. int main()  
  167. {  
  168.     node *head=creat();  
  169.     print(head);  
  170.     int n=length(head);  
  171.     printf("%d\n",n);  
  172.     del(head,4);  
  173.     print(head);  
  174.     sort(head);  
  175.     print(head);  
  176.     insert(head,5);  
  177.     print(head);  
  178.     node *hed=reserve(head);  
  179.     print(hed);  
  180.     return 1;  
  181.  
  182. }