数据结构 Day2 链式存储

线性表的链式存储

    解决顺序存储的缺点，插入和删除，动态存储问题。

特点：
线性表链式存储结构的特点是一组任意的存储单位存储线性表的数据元素，存储单元可以是连续的，也可以不连续。可以被存储在任意内存未被占用的位置上。
    
    所以前面的顺序表只需要存储数据元素信息就可以了。在链式结构中还需要一个元素存储下一个元素的地址。
    
    为了表示每个数据元素，ai与其直接后继数据元素ai+1之间的逻辑关系，对ai来说，除了存储其本身的信息外，还需要存一个指示器直接后续的信息。把存储元素信息的域叫数据域，把存储直接后继位置的域叫指针域。这两部分信息组成数据元素ai的存储映像，叫结点(Node)

    单链表中，c语言的描述

typedef struct person {
    char name[32];
    char sex;
    int age;
    int score;
}DATATYPE;
 

typedef struct node {
    DATATYPE data;
    struct node *next,*prev;
}LinkNode;
 

typedef struct list {
    LinkNode *head; //存放链表公共信息
    int tlen; //最多只能装一百个节点 则不能省略，其余情况可省略
    int clen; //节点个数
}LinkList;

LinkList *CreateLinkList(int len); 
int InsertHeadLinkList(LinkList *list, DATATYPE data); // 头插
int ShowLinkList(LinkList *list);
LinkNode *FindLinkList(LinkList *list, char *name);
int DeleteLinkList(LinkList *list, char *name);
int ReviseLinkList(LinkList *list, char *name, DATATYPE data);
int DestroyLinkList(LinkList *list);
int InsertTailLinkList(LinkList *list, DATATYPE data);

实例   1）打印

main.c

#include <stdio.h>
#include "doulink.h"
int main()
{
       DATATYPE data[5]={
          {"zhangsan",'m',20,70},
          {"lisi",'f',21,60},
          {"wangmazi",'m',25,80},
          {"liubei",'f',30,85},
          {"caocao",'f',40,90},
      };

    DouLinkList* dl = CreateDouLinkList();

    InsertHeadLinkList(dl,&data[0]);
    InsertHeadLinkList(dl,&data[1]);
    InsertHeadLinkList(dl,&data[2]);

    ShowDouLinkList(dl,DIR_FORWARD);
    printf("-------------back---------------\n");
    ShowDouLinkList(dl,DIR_BACKWARD);

    printf("Hello World!\n");
    return 0;
}

 doulink.c

#include "doulink.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

DouLinkList *CreateDouLinkList()
{
    DouLinkList* dl = (DouLinkList*)malloc(sizeof(DouLinkList));
    if(NULL == dl)
    {
        perror("CreateDouLinkList malloc");
        //exit(1);
        return NULL；
    }
    dl->head =NULL;
    dl->clen = 0 ;

    return dl;
}

int InsertHeadLinkList(DouLinkList *list, DATATYPE *data)
{
    DouLinkNode*newnode = malloc(sizeof(DouLinkNode));
    if(NULL == newnode)
    {
        perror("InsertHeadLinkList malloc");
       // exit(1);
        return 1；
    }
    memcpy(&newnode->data,data,sizeof(DATATYPE));
    newnode->next = NULL;
    newnode->prev= NULL;

    if(0==list->clen)//empty
    {
        list->head = newnode;
    }
    else
    {
        newnode->next = list->head;
        list->head->prev = newnode;
        list->head = newnode;
    }
    list->clen++;
    return 0;


}

int ShowDouLinkList(DouLinkList *list, DIRECT direct)
{
    int i = 0 ;
    DouLinkNode* tmp = list->head;
    if(direct==DIR_FORWARD)
    {
             for(i=0;i<GetSizeDouLinkList(list);i++)
        {
            printf("%s %c %d %d\n",tmp->data.name,tmp->data.sex,tmp->data.age,tmp->data.score);
            tmp=tmp->next;
        }
    }
    else
    {
        while(tmp->next)
        {
            tmp=tmp->next;
        }
        for(i=0;i<GetSizeDouLinkList(list);i++)
        {
            printf("%s %c %d %d\n",tmp->data.name,tmp->data.sex,tmp->data.age,tmp->data.score);
            tmp=tmp->prev;
        }
    }
    return 0;
}

int GetSizeDouLinkList(DouLinkList *list)
{
    return list->clen;
}

 doulink.h

#ifndef DOULINK_H
#define DOULINK_H
typedef struct{
    char name[32];
    char sex;
    int age;
    int score;
}DATATYPE;

typedef struct node {
    DATATYPE data;
    struct node *next,*prev;
}DouLinkNode;

typedef struct{
    DouLinkNode *head;
    int clen;
}DouLinkList;
typedef enum{DIR_FORWARD,DIR_BACKWARD}DIRECT;
DouLinkList* CreateDouLinkList();
int InsertHeadLinkList(DouLinkList *list, DATATYPE *data);
int ShowDouLinkList(DouLinkList *list,DIRECT direct);
int GetSizeDouLinkList(DouLinkList *list);
#endif // DOULINK_H

  实例  2)查找

#include <stdio.h>
#include "doulink.h"
#include<string.h>
int findbyname(DATATYPE *data,void*arg)
{
    return (0==strcmp(data->name,(char *) arg));
}
int findbyage(DATATYPE *data ,void *arg)
{
    return data->age == *(int*)arg;
}
int main()
{
       DATATYPE data[5]={
          {"zhangsan",'m',20,70},
          {"lisi",'f',21,60},
          {"wangmazi",'m',25,80},
          {"liubei",'f',30,85},
          {"caocao",'f',40,90},
      };

    DouLinkList* dl = CreateDouLinkList();

    InsertHeadLinkList(dl,&data[0]);
    InsertHeadLinkList(dl,&data[1]);
    InsertHeadLinkList(dl,&data[2]);

    ShowDouLinkList(dl,DIR_FORWARD);
    printf("-------------back---------------\n");
    ShowDouLinkList(dl,DIR_BACKWARD);
    printf("-------------find---------------\n");
    //查找
    char want_name[]="lisi";
    int want_age = 25;
    DouLinkNode *tmp = FindLinkList(dl,findbyage,&want_age);
    if(tmp == NULL)
    {
        printf("catnot find %s\n",want_name);
    }
    else
    {
        printf("find %s %d\n",tmp->data.name,tmp->data.score);
    }
    printf("Hello World!\n");
    return 0;
}

#include "doulink.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

DouLinkList *CreateDouLinkList()
{
    DouLinkList* dl = (DouLinkList*)malloc(sizeof(DouLinkList));
    if(NULL == dl)
    {
        perror("CreateDouLinkList malloc");
        exit(1);
    }
    dl->head =NULL;
    dl->clen = 0 ;

    return dl;
}

int InsertHeadLinkList(DouLinkList *list, DATATYPE *data)
{
    DouLinkNode*newnode = malloc(sizeof(DouLinkNode));
    if(NULL == newnode)
    {
        perror("InsertHeadLinkList malloc");
        exit(1);
    }
    memcpy(&newnode->data,data,sizeof(DATATYPE));
    newnode->next = NULL;
    newnode->prev= NULL;

    if(0==list->clen)//empty
    {
        list->head = newnode;
    }
    else
    {
        newnode->next = list->head;
        list->head->prev = newnode;
        list->head = newnode;
    }
    list->clen++;
    return 0;


}

int ShowDouLinkList(DouLinkList *list, DIRECT direct)
{
    int i = 0 ;
    DouLinkNode* tmp = list->head;
    if(direct==DIR_FORWARD)
    {
             for(i=0;i<GetSizeDouLinkList(list);i++)
        {
            printf("%s %c %d %d\n",tmp->data.name,tmp->data.sex,tmp->data.age,tmp->data.score);
            tmp=tmp->next;
        }
    }
    else
    {
        while(tmp->next)
        {
            tmp=tmp->next;
        }
        for(i=0;i<GetSizeDouLinkList(list);i++)
        {
            printf("%s %c %d %d\n",tmp->data.name,tmp->data.sex,tmp->data.age,tmp->data.score);
            tmp=tmp->prev;
        }
    }
    return 0;
}

int GetSizeDouLinkList(DouLinkList *list)
{
    return list->clen;
}

DouLinkNode *FindLinkList(DouLinkList *list, PFUN fun, void *arg)
{
    DouLinkNode *tmp = list->head;
    int size = GetSizeDouLinkList(list);
    int i =0;
    for(i=0;i<size;i++)
    {
        if(fun(&tmp->data,arg))//Pfun(DATATYPE *list，void *arg)//fun会带着内容进入主函数上的findby...
        {
            return tmp;
        }
        tmp=tmp->next;
    }
    return NULL;
}

 

#ifndef DOULINK_H
#define DOULINK_H
typedef struct{
    char name[32];
    char sex;
    int age;
    int score;
}DATATYPE;
typedef int(*PFUN)(DATATYPE *list ,void *arg);//
typedef struct node {
    DATATYPE data;
    struct node *next,*prev;
}DouLinkNode;

typedef struct{
    DouLinkNode *head;
    int clen;
}DouLinkList;
typedef enum{DIR_FORWARD,DIR_BACKWARD}DIRECT;
DouLinkList* CreateDouLinkList();
int InsertHeadLinkList(DouLinkList *list, DATATYPE *data);
int ShowDouLinkList(DouLinkList *list,DIRECT direct);
int GetSizeDouLinkList(DouLinkList *list);
DouLinkNode *FindLinkList(DouLinkList *list, PFUN fun ,void *arg);
#endif // DOULINK_H

    顺序表和链表 优缺点
    存储方式：
        顺序表是一段连续的存储单元
        链表是逻辑结构连续物理结构（在内存中的表现形式）不连续
    时间性能，
        查找 顺序表O(1)
             链表  O(n)
        插入和删除
            顺序表 O(n)
            链表   O(1)
            
    空间性能
            顺序表 需要预先分配空间，大小固定
            链表， 不需要预先分配，大小可变，动态分配
            
            
    循环链表
        简单的来说，就是将原来单链表中最有一个元素的next指针指向第一个元素或头结点，链表就成了一个环，头尾相连，就成了循环链表。circultlar linker list.
        
        注意非空表，和空表。多数会加入头结点。
        原来结束的条件是
        p->next != NULL ------->>>>> p-next != Head 
        
    双向链表
    double link list。
    
    typedef struct DulNode
    {
    
        ElemType date;
        struct DulNode *pri;
        sturct DulNode *next；
    }DulNode,*DuLinkList;