链表－链式存储

链表的线性存储

//
//  main.c
//  线性表－链式存储
//


#include "stdio.h"
#include "string.h"
#include "ctype.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"

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

#define MAXSIZE 20

typedef int Status;
typedef int ElemType;


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

//单链表的存储结构，由数据域和指针域组成
typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;

typedef struct Node *LinkList;//定义LinkList是指向Node的指针

//初始化
Status InitList(LinkList *L)
{
    *L=(LinkList)malloc(sizeof(Node));//向系统申请sizeof(Node)大小的内存空间，地址存放到*L中
    if(!(*L))
        return ERROR;
    (*L)->next=NULL;//L是指向LinkList的指针，(*L)就是一个LinkList变量，也就是一个指向Node的指针
    
    return OK;
}


Status ListEmpty(LinkList L)
{
    if(L->next)
        return FALSE;
    else
        return TRUE;
}


Status ClearList(LinkList *L)
{
    LinkList p,q;
    p=(*L)->next;
    while(p)
    {
        q=p->next;
        free(p);
        p=q;
    }
    (*L)->next=NULL;
    return OK;
}

//返回链表长度，不包含头节点
int ListLength(LinkList L)
{
    int i=0;
    LinkList p=L->next;//这里L是LinkList变量，指向Node的指针，p是链表中第一个节点
    while(p)
    {
        i++;
        p=p->next;
    }
    return i;
}


Status GetElem(LinkList L,int i,ElemType *e)
{
    int j;
    LinkList p;
    p = L->next;
    j = 1;
    while (p && jnext;
        ++j;
    }
    if ( !p || j>i )
        return ERROR;
    *e = p->data;
    return OK;
}

//链表中值为e的节点所在位置
int LocateElem(LinkList L,ElemType e)
{
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        if(p->data==e)
            return i;
        p=p->next;
    }
    
    return 0;
}


//在链表中第i个节点后面插入值为e的节点
Status ListInsert(LinkList *L,int i,ElemType e)
{
    int j;
    LinkList p,s;//p,s是两个指向Node型数据的指针变量
    p = *L;
    j = 1;
    //找到第i个结点
    while (p && j < i)
    {
        p = p->next;
        ++j;
    }
    if (!p || j > i)
        return ERROR;   /* 若没有找到第i个节点，报错 */
    s = (LinkList)malloc(sizeof(Node));  /*  生成一个Node节点 */
    s->data = e;
    s->next = p->next;      /* 令新生成节点的next指向第i＋1个节点 */
    p->next = s;          /* 令第i个节点的next指向新生成节点 */
    return OK;
}

/* 删除链表中第i个结点，并返回第i个结点的值*/
Status ListDelete(LinkList *L,int i,ElemType *e)
{
    int j;
    LinkList p,q;
    p = *L;
    j = 1;
    while (p->next && j < i)	/* 寻找第i-1个结点p */
    {
        p = p->next;
        ++j;
    }
    if (!(p->next) || j > i)
        return ERROR;           /* 若不存在第i个结点报错 */
    q = p->next;
    p->next = q->next;			/* 第i-1个结点的next指向第i+1个结点 */
    *e = q->data;               /* 将第i个结点的值赋给e*/
    free(q);                    /* 释放第i个结点的内存 */
    return OK;
}


/* 打印链表中每个节点的数值 */
Status ListTraverse(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        visit(p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}

//生成链表，头插法，即新节点插入在表头
void CreateListHead(LinkList *L, int n)
{
    LinkList p;
    int i;
    srand(time(0));//生成随机数
    *L = (LinkList)malloc(sizeof(Node));//生成一个头节点
    (*L)->next = NULL;
    
    for (i=0; idata = rand()%100+1;
        
        p->next = (*L)->next;//将新节点插入表头
        (*L)->next = p;
    }
}

//尾插法，新节点插入在表尾
void CreateListTail(LinkList *L, int n)
{
    LinkList p,r;
    int i;
    srand(time(0));                      /* 初始化随机数种子*/
    *L = (LinkList)malloc(sizeof(Node)); /* 创建头节点 */
    r=*L;                                /* r始终指向表尾节点 */
    for (i=0; idata = rand()%100+1;
        r->next=p;                        /* 新生成节点放在表尾 */
        r = p;                            /* 让r指向新的表尾 */
    }
    r->next = NULL;                       /* 表示当前链表结束 */
}

int main()
{
    LinkList L;//L是指向头节点的
    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L);
    printf("初始化后链表的长度ListLength(L)=%d\n",ListLength(L));
    for(j=1;j<=5;j++)
        i=ListInsert(&L,1,j);
    printf(" 插入1～5五个数字后L.data=");
    ListTraverse(L);
    
    printf("ListLength(L)=%d \n",ListLength(L));
    i=ListEmpty(L);
    printf("L是否为空i=%d(1:是  0:否)\n",i);
    
    i=ClearList(&L);
    printf("清空后ListLength(L)=%d\n",ListLength(L));
    i=ListEmpty(L);
    printf("L是否为空i=%d(1:是  0:否)\n",i);
    
    for(j=1;j<=10;j++)
        ListInsert(&L,j,j);
    printf("将1～10插入到链表中L.data=");
    ListTraverse(L);
    
    printf("ListLength(L)=%d \n",ListLength(L));
    
    ListInsert(&L,1,0);
    printf("将0插入到链表中第一个节点后L.data=");
    ListTraverse(L);
    printf("ListLength(L)=%d \n",ListLength(L));
    
    GetElem(L,5,&e);
    printf("链表中第五个节点的值为%d\n",e);
    for(j=3;j<=4;j++)
    {
        k=LocateElem(L,j);//链表L中，值为j的节点所在位置，为k
        if(k)
            printf("链表中第%d个元素的值为%d\n",k,j);
        else
            printf("没有值为%d的元素",j);
    }
    
    
    k=ListLength(L); /* 返回链表的长度*/
    for(j=k+1;j>=k;j--)
    {
        i=ListDelete(&L,j,&e);/* 删除第j个元素，并返回第j个元素的值 */
        if(i==ERROR)
            printf("不存在第%d个结点\n",j);
        else
            printf("第%d个结点的值为%d\n",j,e);
    }
    printf("删除该结点后L.data=");
    ListTraverse(L);
    
    j=5;
    ListDelete(&L,j,&e); /* 删除链表中第5个元素，并返回第五个节点的值 */
    printf("删除第%d的数据值为%d\n",j,e);
    
    printf("删除该结点后L.data=");
    ListTraverse(L);
    
    i=ClearList(&L);
    printf("清空链表后ListLength(L)=%d\n",ListLength(L));
    CreateListHead(&L,20);
    printf("头插法生成链表L.data=");
    ListTraverse(L); 
    
    i=ClearList(&L);
    printf("清空链表后ListLength(L)=%d\n",ListLength(L));
    CreateListTail(&L,20);
    printf("尾插法生成链表L.data=");
    ListTraverse(L); 
    
    
    return 0;
}

运行结果：

初始化后链表的长度ListLength(L)=0
 插入1～5五个数字后L.data=5 4 3 2 1 
ListLength(L)=5 
L是否为空i=0(1:是  0:否)
清空后ListLength(L)=0
L是否为空i=1(1:是  0:否)
将1～10插入到链表中L.data=1 2 3 4 5 6 7 8 9 10 
ListLength(L)=10 
将0插入到链表中第一个节点后L.data=0 1 2 3 4 5 6 7 8 9 10 
ListLength(L)=11 
链表中第五个节点的值为4
链表中第4个元素的值为3
链表中第5个元素的值为4
不存在第12个结点
第11个结点的值为10
删除该结点后L.data=0 1 2 3 4 5 6 7 8 9 
删除第5的数据值为4
删除该结点后L.data=0 1 2 3 5 6 7 8 9 
清空链表后ListLength(L)=0
头插法生成链表L.data=3 82 59 18 62 3 84 91 75 71 92 55 63 51 57 12 18 28 16 78 
清空链表后ListLength(L)=0
尾插法生成链表L.data=78 16 28 18 12 57 51 63 55 92 71 75 91 84 3 62 18 59 82 3 
Program ended with exit code: 0

上述程序中，在函数CreateListTail和CreateListHead中，都用到了函数stand(time(0)),

rand()函数产生的是“伪”随机数，它是由软件做成m序列发生器输出的。这个m序列发生器在初始状态不变的情况也，产生的“序列”是相同的——比如说在某一种状态（如0000...）下，它产生的序列是1 2 3 4 5 2 3 5 1 6......那么，下一次在0000...的初始状态下产生的序列还是1 2 3 4 5 2 3 5 1 6......但是，如果初始状态不同，则产生的序列就不同了。为了使我们得到的“伪”随机数更像“真”随机数，我们希望每次调用rand()函数前的初始状态是变化的。为此，C设计了一个srand()函数，它预置m序列发生器的初始状态，而且用一个随时可变的时间函数的返回值来调用srand()，这样它预置的初始状态就是随时间变化的，这样产生的m序列尽管仍然是“伪”的，但就有了以假乱真的效果。