#include<iostream>  
#include<stdio.h>  
#include<string.h>  
#include<malloc.h>  
  
#define CHAR char  
#define VARTYPE CHAR //默认存放char类型  
  
using namespace std;  
  
struct myNode;  
typedef struct myNode Node;  
typedef Node* List;  
typedef Node* PtrToNode;  
  
  
struct myNode  
{  
    VARTYPE data;  
    PtrToNode next;  
};  
//在p位置后插入元素  
void _insert(List T,int p,VARTYPE x);  
//尾部插入元素  
void _push(List T,VARTYPE x);  
//移除内容为x的元素  
void _removec(List T,VARTYPE x);  
//移除内容为编号为p的元素  
void _removep(List T,int p);  
//删除链表  
void _dellist(List T);  
//打印char类型链表内容  
#ifdef CHAR  
void _print(List T);  
#endif  
//清空链表  
void _clear(List T);  
//创建链表  
List createlist();  
//返回编号为p的元素  
VARTYPE _findc(List T,int p);  
//链表元素个数  
int _size(List T);  
int main()  
{  
    List T = createlist();  
    _push(T,'a');  
    _push(T,'b');  
    _push(T,'c');  
    _push(T,'d');  
    _push(T,'e');  
    _push(T,'e');  
    _push(T,'d');  
    //_insert(T,2,'p');  
    // _removec(T,'e');  
    //_removep(T,3);  
    //_print(T);  
    //_clear(T);  
    _push(T,'p');  
    _push(T,'q');  
    //printf("%d",_size(T));  
    //printf("%c",_findc(T,3));  
    _print(T);  
    _dellist(T);  
    return 0;  
}  
  
//在p位置后插入元素  
void _insert(List T,int p,VARTYPE x)  
{  
    PtrToNode pre;  
    PtrToNode tmp;  
    int i = 0;  
    while(NULL!=T)  
    {  
        pre = T;  
        T = T->next;  
        if(++i==p)  
            break;  
    }  
    tmp = (PtrToNode)malloc(sizeof(Node));  
    if(NULL==tmp)  
        perror("malloc");  
    else  
    {  
        tmp->data = x;  
        pre->next = tmp;  
        tmp->next = T;  
    }  
};  
//尾部插入元素  
void _push(List T,VARTYPE x)  
{  
    while(NULL!=T->next)  
        T = T->next;  
    PtrToNode tmp = (PtrToNode)malloc(sizeof(Node));  
    if(NULL==tmp)  
        perror("malloc");  
    else  
    {  
        tmp->data = x;  
        tmp->next = NULL;  
        T->next = tmp;  
    }  
};  
//移除内容为x的元素  
void _removec(List T,VARTYPE x)  
{  
    PtrToNode pre;  
    pre = T;  
    T = T->next;  
    while(NULL!=T)  
    {  
        if(T->data==x)  
        {  
            pre->next = T->next;  
            free(T);  
        }  
        else  
            pre = T;  
        T = pre->next;  
    }  
};  
//移除内容为编号为p的元素  
void _removep(List T,int p)  
{  
    PtrToNode pre;  
    int i = 0;  
    while(NULL!=T)  
    {  
        pre = T;  
        T = T->next;  
        if(++i==p)  
            break;  
    }  
    pre->next = T->next;  
    free(T);  
};  
//删除链表  
void _dellist(List T)  
{  
    PtrToNode tmp = T;  
    while(NULL!=T)  
    {  
        tmp = T->next;  
        free(T);  
        T = tmp;  
    }  
};  
//打印char类型链表内容  
#ifdef CHAR  
void _print(List T)  
{  
    T = T->next;  
    while(NULL!=T)  
    {  
        printf("%c ",T->data);  
        T=T->next;  
    }  
};  
#endif  
//清空链表  
void _clear(List T)  
{  
    _dellist(*&T->next);  
    T->next = NULL;  
}  
//创建链表  
List createlist()  
{  
    PtrToNode tmp = (PtrToNode)malloc(sizeof(Node));  
    tmp->next=NULL;  
    return tmp;  
}  
//返回编号为p的元素  
VARTYPE _findc(List T,int p)  
{  
    int i = 0;  
    while(NULL!=T)  
    {  
        T = T->next;  
        if(++i==p)  
            break;  
    }  
    return T->data;  
}  
//链表元素个数  
int _size(List T)  
{  
    int i = -1;  
    while(NULL!=T)  
    {  
        T = T->next;  
        ++i;  
    }  
    return i;  
}   

2014/10/15改进版

#include<iostream>  
#include<cstdio>  
#include<string>  
#include<malloc.h>  
using namespace std;  
  
struct mynode;  
typedef struct mynode Node;  
struct mynode  
{  
    int data;  
    Node *next;  
};  
  
char str[] = {"\  
-------------------------------------------------\n\  
-------C：创建链表-------------------------------\n\  
-------D：删除节点-------------------------------\n\  
-------I：插入新节点-----------------------------\n\  
-------P：输出节点-------------------------------\n\  
-------R：链表逆置-------------------------------\n\  
-------Q：撤销链表-------------------------------\n\  
-------E：退出-----------------------------------\n\  
-------------------------------------------------\n\  
"  
             };  
  
Node* createlist()  
{  
    int n;  
    Node *head,*p,*q;  
    head = (Node *)malloc(sizeof(Node));  
    if(NULL==head)  
    {  
        perror("out of space");  
        exit(1);  
    }  
    head->next = NULL;  
    printf("请输入节点个数:");  
    scanf("%d",&n);  
    p = head;  
    for(int i=1; i<=n; ++i)  
    {  
        q = (Node *)malloc(sizeof(Node));  
        if(NULL==head)  
        {  
            perror("out of space");  
            exit(1);  
        }  
        q->next = NULL;  
        p->next = q;  
        printf("data%2d: ",i);  
        scanf("%d",&q->data);  
        p = p->next;  
    }  
    return head;  
}  
  
void dellist(Node *head)  
{  
    Node *p;  
    while(head)  
    {  
        p = head->next;  
        free(head);  
        head = p;  
    }  
}  
  
void printlist(Node *head)  
{  
    int i = 1;  
    head = head->next;  
    while(head)  
    {  
        printf("data%2d: %d\n",i++,head->data);  
        head = head->next;  
    }  
}  
  
void _insert(Node *head)  
{  
    Node *temp;  
    int pos;  
    if(NULL==head)  
        return;  
    printf("请输入插入节点位置:");  
    scanf("%d",&pos);  
    if(pos<0)  
        return;  
    else  
    {  
        while(head->next&&pos--)  
            head = head->next;  
    }  
    temp = (Node *)malloc(sizeof(Node));  
    if(NULL==temp)  
    {  
        perror("out of space");  
        exit(0);  
    }  
    printf("请输入data的值:");  
    scanf("%d",&temp->data);  
    temp->next = head->next;  
    head->next = temp;  
}  
  
void delnode(Node *head)  
{  
    int pos;  
    Node *p;  
    printf("删除节点编号:");  
    scanf("%d",&pos);  
    if(pos<1)  
        return ;  
    while(head&&--pos)  
    {  
        head = head->next;  
    }  
    if(NULL==head)  
        return;  
    p = head->next;  
    head->next = p->next;  
    free(p);  
}  
  
void _reverse(Node* head)  
{  
    Node *p1,*p2,*p3;  
    p1 = head->next;  
    if(NULL==p1||p1->next==NULL)  
        return;  
    p2 = p1->next;  
    p3 = p2->next;  
    while(p3)  
    {  
        p2->next = p1;  
        p1 = p2;  
        p2 = p3;  
        p3 = p3->next;  
    }  
    p2->next = p1;  
    head->next->next = NULL;  
    head->next = p2;  
    return;  
}  
  
int main()  
{  
    char p;  
    printf(str);  
    while(scanf("%c",&p)!=EOF)  
    {  
        if(p>='a'&&p<='z')p = p-('a'-'A');  
        Node *_list;  
        switch(p)  
        {  
        case 'C':  
            dellist(_list);  
            _list = createlist();  
            break;  
        case 'D':  
            delnode(_list);  
            break;  
        case 'I':  
            _insert(_list);  
            break;  
        case 'P':  
            printlist(_list);  
            break;  
        case 'R':  
            _reverse(_list);  
            break;  
        case 'Q':  
            dellist(_list);  
            break;  
        case 'E':  
            dellist(_list);  
            return 0;  
            break;  
        default:  
            printf(str);  
            break;  
        }  
    }  
}