链表：

1、注意是否有带头结点。

2、单链表的建立：顺序建表（尾插法）、逆序建表（头插法）。

3、单链表的插入、删除操作需要寻找前驱结点。

单链表的建立、排序和翻转，都是针对有头结点的单链表。

#include <iostream>
using namespace std;

typedef struct Node
{
    int data;
    Node * next;
}Node,*List;

//顺序建表：尾插法
void CreateLinkList(List& L, int n)
{
    //  建立空表
    L = (List)malloc(sizeof(Node));
    L->next = NULL;    //空表
    List p = L;    //用p指向表尾
    //  插入元素
    for(int i=0; i<n; i++ )
    {
        int x;
        cin>>x;
        List s = (List) malloc(sizeof(Node));
        s->data = x;
        //  插入表尾
        s->next = p->next;
        p->next = s;
        p = s;    //  新的表尾
    }
}

//逆序建表：头插法
void CreateLinkList2(List& L, int n)
{
    //  建立空表
    L = (List) malloc(sizeof(Node));
    L->next = NULL;  // 空表
    //  插入元素
    for (int i=0; i<n; i++ )
    {
        int x;
        cin>>x;
        List s = (List) malloc(sizeof(Node));
        s->data = x;
        //  插入表头
        s->next = L->next;
        L->next = s;
    }
}

void PrintLinkList(List L)
{
   List p = L->next;
   while( p!=NULL )
   {
       cout<<p->data<<" ";
       p = p->next;
   }
   cout<<endl;
}

int GetLength(Node *head)
{
    int len = 0;
    List p = head->next;
    while(p)
    {
        ++len;
        p = p->next;
    }
    return len;
}

void DestroyList(List & L)
{
    List p = L;
    List q = NULL;
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
}

//采用插入法将单链表中的元素排序。
void InsertionSort(List & L)
{
    List h=L->next;      // 原链表
    L->next=NULL;      // 新空表
    List s=NULL,p=NULL;
    while(h)
    {
        // 从原链表中取下结点s
        s=h;  h=h->next;
        // 在新表中查找插入位置
        p=L;
        while (p->next && p->next->data<=s->data)
        p=p->next;
        // 在p之后插入s
        s->next=p->next;
        p->next=s;
    }
}

//采用选择法将单链表中的元素排序。
void SelectionSort(List & L)
{
    List p=L;
    List q=NULL,s=NULL,m=NULL;
    while (p->next)
    {
        // 选择最小(从p->next至表尾)
        q=p;     // 最小元素的前驱q
        s=p;
        while(s->next)
        {
            if(s->next->data<q->next->data)  q=s;
            s=s->next;
        }
        m=q->next;     // 找到最小m
        // 最小元素m插入有序序列末尾(p之后)
        if (q!=p)
        {
            q->next=m->next;      // 解下最小m
            m->next=p->next;      // 插入p之后
            p->next=m;
        }
        p=p->next;     // L->next至p为有序序列
    }
}

//单链表就地逆置
void ReverseList(Node* h)
{
    Node* p = h->next;  // 原链表
    h->next = NULL; // 新表(空表)
    while(p != NULL)
    {
        Node* q = p->next;  // 保存下个结点q
        p->next = h->next;
        h->next = p;
        p = q;
    }
}

int main()
{
    List head = NULL;
    CreateLinkList(head,5);
    PrintLinkList(head);
    cout<<"Len: "<<GetLength(head)<<endl;

    InsertionSort(head);
    PrintLinkList(head);

    ReverseList(head);
    PrintLinkList(head);

    DestroyList(head);

    return 0;
}