单链表的定义：

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

单链表的初始化(带头节点)：

bool InitList(LinkList* L)
{
    *L = (LinkList)malloc(sizeof(Node));
    if (*L == NULL)
        return false;
    (*L)->next = NULL;
    return true;
}

判断单链表是否为空(带头节点)：

bool Empty(LinkList L)
{
    if (L->next == NULL)
        return true;
    else
    {
        return false;
    }
}

单链表的整表创建(带头节点)：

bool ListStart(LinkList* L, int n)
{
    Node* p;
    int i;
    srand(time(0));　　　　　　　　　　　　　　　　//初始化随机种子
    *L = (Node*)malloc(sizeof(Node));
    (*L)->next = NULL;　　　　　　　　　　　　　　//先建立一个带头结点的单链表
    for (i = 0; i < n; i++)
    {
        p = (Node*)malloc(sizeof(Node));　　　//生成新结点
        if (p == NULL)
            return false;　　　　　　　　　　　　//判断获取内存是否成功
        p->data = rand() % 100 + 1;　　　　　　//随机生成100以内的数字
        p->next = (*L)->next;
        (*L)->next = p;　　　　　　　　　　　　　//采用头插法，插入到表头
    }
    return true;
}

显示整个单链表：

void ListShow(LinkList L)
{
    printf("\n");
    Node* p;　　　　　　　　　　　　　　　　　　　//创建新结点，作为额外指针
    p = L->next;　　　　　　　　　　　　　　　　 //p越过头结点，指向第一个结点
    while (p != NULL)
    {
        printf("%d-", p->data);　　　　　　　 //输出结点的值
        p = p->next;　　　　　　　　　　　　　　//p指向下一个结点
    }
}

单链表插入(带头结点，头插法)：

bool ListInsert(LinkList* L, int i, int* e)
{
if (i < 1)
return false;　　　　　//插入位置不合法
Node * p, *s;
p = *L;　　　　　　　　 //p作为额外指针
int j = 0;　　　　　　 //j指示p的位置
while (p && j < i-1) //寻找i-1个结点
{
p = p->next;
j++;
}
if (p == NULL)
return false;　　　　 //i不合法
s = (Node*)malloc(sizeof(Node));
s->data = *e;
s->next = p->next;
p->next = s;
return true;
}

单链表插入(带头结点，尾插法)：

bool ListAdd(LinkList* L, int i, int* e)
{
    if (i < 1)
        return false;
    Node* p;
    p = *L;
    int j = 0;
    while (p && j < i)　　　　　　　　//寻找第i个结点
    {
        p = p->next;
        j++;
    }
    if (p == NULL)
        return false;
    Node* s;
    s = (Node*)malloc(sizeof(Node));
    s->data = *e;
    s->next = p->next;
    p->next = s;　　　　　　　　　　//将s插入到第i个后面
    return true;
}

单链表删除(带头结点)：

bool ListDelete(LinkList* L, int i, int* e)
{
    if (i < 1)
        return false;
    int j = 0;
    Node* p;
    p = *L;
    while (p && j < i - 1)　　//寻找第i-1个结点
    {
        p = p->next;
        j++;
    }
    if (p == NULL)　　　　　　//删除位置不合法，结点i-1超出链表
        return false;
    if (p->next == NULL)　　//删除位置不合法，结点i超出链表
        return false;
    Node* q = p->next;
    p->next = q->next;
    *e = q->data;
    free(q);
    return true;
}

按位查找(带头结点)：

bool GetElem(LinkList L,int i, int* e)
{
    if (i < 1)
        return false;
    int j = 0;
    Node* p;
    p = L;
    while (p && j < i)
    {
        p = p->next;
        j++;
    }
    if (p == NULL)
        return false;
    *e = p->data;
    return true;
}

按值查找(带头结点)：

bool LocateElem(LinkList L, int e, int *i)
{
    if (Empty(L))
        return false;
    int j = 0;
    Node* p;
    p = L;
    while (p != NULL)
    {
        if (p->data == e)
        {
            *i = j;
            return true;
        }
        p = p->next;
        j++;
    }
}

测试代码(main):

void main(void)
{
    printf("begin\n");
    LinkList L;
    int e,e1 = 16;
    ListStart(&L, 11);
    ListShow(L);
    GetElem(L, 6, &e);
    printf("n6=%d\n", e); 
    ListInsert(&L, 3, &e1);
    ListShow(L);
    LocateElem(L, 16, &e);
    printf("值16-i=%d\n", e);
    ListShow(L);
}

测试结果：