数据结构 --- 线性表（单链表）

工程目录结构:

common.h:

//#ifndef __common_h__
//#define __common_h__

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0 

#define MAXSIZE 20

typedef int Status;        //函数的返回结果，OK、ERREO、TRUE、FALSE
typedef int ElemType;   //结点数据域的数据类型

//#endif

common.c:

#include "common.h"

Status visit(ElemType e)
{
    printf("%d , ", e);
    return OK;
}

LinkList.h:

//单链表结点定义
typedef struct Node
{
    ElemType data;
    struct  Node *next;
}Node;

typedef  struct  Node *LinkList;  //单链表定义

LinkList.c:

#include <stdio.h>
#include <malloc.h>
#include <math.h>  
#include <time.h>
#include <stdlib.h>

//注意以下两个 .h 的包含顺序
#include "common.h"
#include "LinkList.h"

//初始化单链表
Status InitLinkList(LinkList *L)
{
    *L = (LinkList)malloc(sizeof(Node));    //生成头结点，并式指针指向它
    if (*L == NULL)                            //头结点生成失败
    {
        return ERROR;
    }

    (*L)->next = NULL;
    return OK;
}

//计算单链表的长度， 该单链表带有头结点
int ListLength(LinkList L)
{
    int count = 0;

    if (NULL != L)
    {
        LinkList p = L->next;
        while (NULL != p)
        {
            ++count;
            p = p->next;
        }
    }

    return count;
}



//在L的第i个位置插入元素e
Status ListInsert(LinkList *L, int i, ElemType e)
{
    LinkList p = *L;
    int index = 1;
    //查找第i个结点
    while (p && index < i)
    {
        p = p->next;
        ++index;
    }

    //第一个元素不存在
    if (!p && index > i)
    {
        return ERROR;
    }

    //生成新结点
    LinkList s = (LinkList)malloc(sizeof(Node));
    s->next = p->next;
    s->data = e;
    p->next = s;
    return OK;
}

//输出单链表的元素
Status ListTraverse(LinkList L)
{
    if (NULL != L)
    {
        LinkList p = L->next;
        while (NULL != p)
        {
            visit(p->data);
            p = p->next;
        }
        return OK;
    }
    return FALSE;
}

//判断单链表是否为空链表
Status ListEmpty(LinkList L)
{
    if (NULL != L)
    {
        if (NULL == L->next)
        {
            return TRUE;
        }
        else
        {
            return FALSE;
        }
    }
    else
    {
        printf("单链表未初始化\n\n");
        return TRUE;
    }
}



//清除单链表数据，置为空
Status ListClear(LinkList *L)
{
    if (NULL != L)
    {
        LinkList p, q;
        p = (*L)->next;
        while (p)
        {
            q = p->next;
            free(p);
            p = q;
        }

        (*L)->next = NULL;   //置空头结点指针域
        return TRUE;
    }

    return FALSE;
}

//返回第i个元素，e来保存
Status GetElem(LinkList L, int i, ElemType *e)
{
    if (NULL != L)
    {
        int index = 1;
        LinkList p = L->next;
        while (NULL != p && index < i)
        {
            ++index;
            p = p->next;
        }

        //第i个元素不存在
        if (NULL != p && index > i)
        {
            return ERROR;
        }

        *e = p->data;
        return OK;
    }
    return FALSE;
}

//返回第一个值为e的位序(1开始)
int LocateElem(LinkList L, ElemType e)
{
    if (NULL != L)
    {
        int index = 0;
        LinkList p = L->next;
        while (NULL != p)
        {
            ++index;
            if (e == p->data)
            {
                return index;
            }
            p = p->next;
        }
    }
    return 0;
}

//删除第 i 个位置的元素，e保存删除的元素
Status ListDelete(LinkList *L, int i, ElemType *e)
{
    if (NULL != (*L))
    {
        LinkList p = *L;
        int index = 1;
        while (NULL != p->next && index < i)
        {
            ++index;
            p = p->next;
        }

        while (!(p->next) || index > i)
        {
            return ERROR;
        }

        LinkList q = p->next;
        p->next = q->next;
        *e = q->data;
        free(q);
        return OK;
    }
    return ERROR;
}

//随机产生n个元素的值，建立带表头结点的单链线性表L（头插法）
void CreateListHead(LinkList *L, int n)
{
    srand(time(0));   //初始化随机数种子
    LinkList p;
    *L = (LinkList)malloc(sizeof(Node));
    (*L)->next = NULL;
    for (int i = 0; i < n; ++i)
    {
        p = (LinkList)malloc(sizeof(Node));
        p->data = rand() % 100 + 1;    //随机生成100以内的数字
        p->next = (*L)->next;
        (*L)->next = p;                    //插到表头
    }
}

//随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法）
void CreateListTrail(LinkList *L, int n)
{
    srand(time(0));   //初始化随机数种子
    LinkList p,r;
    *L = (LinkList)malloc(sizeof(Node));
    r = *L;            //r为指向尾部的结点
    for (int i = 0; i < n; ++i)
    {
        p = (LinkList)malloc(sizeof(Node));
        p->data = rand() % 100 + 1;        //随机生成100以内的数字
        r->next = p;                    //将表尾终端结点的指针指向新结点
        r = p;                            //将当前的新结点定义为表尾终端结点
    }
    r->next = NULL;  //链表结束
}

//单链表测试的入口
void LinkListStart()
{
    printf("\n######## 单链表 测试 Start ############\n");

    LinkList L = NULL;
    printf("单链表初始化结果: %d\n\n", InitLinkList(&L));
    printf("初始化后，单链表的长度是: %d\n\n", ListLength(L));
    printf("插入元素 1 - 10 \n");
    for (int i = 1; i <= 10; ++i)
        ListInsert(&L, i, i);
    printf("插入的元素分别是: ");
    ListTraverse(L);

    printf("\n\n单链表是否为空: %d\n", ListEmpty(L));
    printf("\n\n单链表的长度是: %d\n", ListLength(L));

    if (OK == ListClear(&L))
    {
        printf("\n单链表置空\n");
        printf("单链表是否为空: %d\n", ListEmpty(L));
        printf("单链表的长度是: %d\n", ListLength(L));
    }

    printf("\n\n\n插入元素 1 - 5 \n");
    for (int i = 1; i <= 5; ++i)
        ListInsert(&L, i, i);
    printf("插入的元素分别是: ");
    ListTraverse(L);
    printf("\n单链表的长度是: %d\n", ListLength(L));

    ListInsert(&L, 1, 0);
    printf("表头插入0后:\n");
    ListTraverse(L);
    printf("\n单链表的长度是: %d\n", ListLength(L));

    ElemType e;
    GetElem(L, 3, &e);
    printf("单链表的第3个元素是: %d\n", e);

    int k = 0;
    for (int i = 2; i <= 4; ++i)
    {
        k = LocateElem(L, i);
        if (0 != k)
        {
            printf("第 %d 个元素的值为 %d\n", k, i);
        }
        else
        {
            printf("没有值为 %d 的元素\n", i);
        }
    }

    int index = 3;
    ListDelete(&L, index, &e);
    printf("\n删除第%d个的元素值为：%d\n", index, e);
    printf("依次输出单链表的元素：");
    ListTraverse(L);

    ListClear(&L);
    printf("\n\n清空单链表后的长度：%d\n", ListLength(L));

    CreateListHead(&L, 6);
    printf("\n创建单链表元素(头插法):\n");
    ListTraverse(L);
    ListClear(&L);


    CreateListTrail(&L, 6);
    printf("\n\n创建单链表元素(尾插法):\n");
    ListTraverse(L);
    ListClear(&L);

    printf("\n\n####### 单链表 测试 End ###########");
}

main.c:

int main()
{
    LinkListStart();
    //StackStart();
    //LinkStackStart();
    getchar();
    return 0;
}