数据结构（2）双向链表

Final Strike

于 2024-07-24 22:36:08 发布

阅读量472

点赞数 5

文章标签：数据结构链表

本文链接：https://blog.csdn.net/qq_54094530/article/details/140665247

版权

#“微软蓝屏”事件暴露了网络安全哪些问题？#

链表

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

特点：
   线性表链式存储结构的特点是一组任意的存储单位存储线性表的数据元素，
   存储单元可以是连续的，也可以不连续。可以被存储在任意内存未被占用的位置上。

   所以前面的顺序表只需要存储数据元素信息就可以了。在链式结构中还需要一个元素存储下一个元素的地址。

   为了表示每个数据元素，ai与其直接后继数据元素ai+1之间的逻辑关系，
   对ai来说，除了存储其本身的信息外，还需要存一个指示器直接后续的信息。
   把存储元素信息的域叫数据域，把存储直接后继位置的域叫指针域。
   这两部分信息组成数据元素ai的存储映像，叫结点(Node);

顺序表和链表的优缺点：

存储方式：
       顺序表是一段连续的存储单元
       链表是逻辑结构连续物理结构（在内存中的表现形式）不连续
   时间性能，
       查找顺序表O(1)
           链表 O(n)
       插入和删除
           顺序表 O(n)
           链表 O(1)

   空间性能
           顺序表需要预先分配空间，大小固定
           链表，不需要预先分配，大小可变，动态分配

   循环链表
       简单的来说，就是将原来单链表中最有一个元素的next指针指向第一个元素或头结点，链表就成了一个环，头尾相连，就成了循环链表。circultlar linker list.

       注意非空表，和空表。多数会加入头结点。
       原来结束的条件是
       p->next != NULL ------->>>>> p-next != Head

双向链表描述：

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;  //因此不需要一个固定的容量（tlen）（total len）
    int clen;
}DouLinkList;

功能：

#ifndef DOULINK_H
#define DOULINK_H
typedef struct{
    char name[32];
    char sex;
    int age;
    int score;
}DATATYPE;
typedef int (*PFUN)(DATATYPE*data,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;  //用于showdoulinklist是
                                                顺序输出还是逆序输出
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);
int RevertDouLinkList(DouLinkList *list);
int DeleteLinkList(DouLinkList *list, PFUN fun,void* arg);
int IsEmptyDouLinkList(DouLinkList *list);
int ModifyDouLinkList(DouLinkList *list,PFUN fun,void* arg,DATATYPE *data);
int DestroyDouLinkList(DouLinkList **list);
int InserPosDouLinkList(DouLinkList *list,DATATYPE *data,int pos);
#endif // DOULINK_H

功能实现：

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

int findbyname(DATATYPE*data,void* arg)   //用于ModifyDouLinkList的回调
{
    return (0 == strcmp(data->name,(char*)arg));
}

int findbyage(DATATYPE*data,void* arg)  //用于ModifyDouLinkList的回调
{
    return data->age == *(int*)arg;
}

DouLinkList *CreateDouLinkList()
{
    //DouLinkList dl ;
    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");
        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;
}

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(0==strcmp(tmp->data.name))
        if(fun(&tmp->data,arg))
        {
            return tmp;
        }
        tmp= tmp->next;
    }
    return NULL;
}

int RevertDouLinkList(DouLinkList *list)
{
    int size = GetSizeDouLinkList(list);
    if(size<2)
    {
        return 0;
    }

    DouLinkNode* prev= NULL;
    DouLinkNode* tmp = list->head;
    DouLinkNode*next= tmp->next;
    while(1)
    {
        tmp->next = prev;
        tmp->prev = next;
        prev= tmp;
        tmp = next;
        if(NULL == tmp)
        {
            break;
        }
        next =next->next;
    }
    list->head = prev;
    return 0;
}

int DeleteLinkList(DouLinkList *list, PFUN fun, void *arg)
{
    if(NULL == list)
    {
        fprintf(stderr,"DouLinkList is null");
        return 1;
    }
    if(IsEmptyDouLinkList(list))
    {
        fprintf(stderr,"DouLinkList is empty");
        return 1;
    }
    DouLinkNode* ret = FindLinkList(list,fun,arg);
    if(NULL==ret)
    {
        fprintf(stderr,"DeleteLinkList error,cant find\n");
        return 1;
    }
    if(ret == list->head)
    {
        list->head = ret->next;
        list->head->prev = NULL;
    }
    else
    {
        if(ret->next)
        ret->next->prev = ret->prev;
        ret->prev->next = ret->next;
    }

    free(ret);
    list->clen--;
    return 0;
}

int IsEmptyDouLinkList(DouLinkList *list)
{
    return 0 == list->clen;
}

int ModifyDouLinkList(DouLinkList *list, PFUN fun, void *arg, DATATYPE *data)
{
    DouLinkNode* ret = FindLinkList(list,fun,arg);
    if(NULL == ret)
    {
        fprintf(stderr,"ModifyDouLinkList error,cant find\n");
        return 1;
    }
    memcpy(&ret->data,data,sizeof(DATATYPE));
    return 0;
}

int DestroyDouLinkList(DouLinkList **list)
{
    DouLinkNode* tmp=(*list)->head;
    while(tmp)
    {
    (*list)->head=(*list)->head->next;
    free(tmp);
    tmp = (*list)->head;

    }
    free(*list);
    (*list)= NULL;
    return 0;
}

int InserPosDouLinkList(DouLinkList *list, DATATYPE *data,int pos)
{
    if(pos<0 ||pos>GetSizeDouLinkList(list))
    {
        fprintf(stderr,"InserPosDouLinkList error,index error\n");
        return 1;

    }
    if(IsEmptyDouLinkList(list) || 0 == pos)
    {
        return InsertHeadLinkList(list,data);
    }
    else
    {
        DouLinkNode* tmp = list->head;
        tmp= list->head;
        DouLinkNode* newnode = (DouLinkNode*)malloc(sizeof(DouLinkNode));
        if(NULL == newnode)
        {
            perror("InserPosDouLinkList malloc");
            return 1;
        }
        memcpy(&newnode->data,data,sizeof(DATATYPE));
        newnode->prev = NULL;
        newnode->next = NULL;
        int i = pos-1;
        while(i--)
        {
            tmp=tmp->next;
        }
        newnode ->prev = tmp;
        newnode->next = tmp->next;

        if(tmp->next)
        {
        tmp->next->prev = newnode;
        }
        tmp->next = newnode;
    }
    list->clen++;
    return 0;
}

结构体中的.与->:

结构体中的.与->:
1.A->a表示A是指向结构体的指针
A.a表示A是结构体

2.“->”是指向结构体成员运算符。
“.”是断点符号，不属于运算符。

3.不论是“->”还是“.”，其访问的对象都是结构体变量（不是指针）

typedef struct 
{
	int a；
	int b；
}ADD；

void swap(ADD add)
{
	int tmp = add->a;
	add->a = add->b;
	add->b = tmp;
}

调用该函数过后，此时主调函数中结构体ADD成员变量a与b的值发生了改变

通过注册回调实现解耦合：

在c语言中，如果模块A中的某个功能在不同应用场景下需要不同的处理方式，
一般采用如下写法:(伪代码)
void AFunc
{
   if(condition1)
   {
       BFunc();
   }
   if(condition1)
   {
       CFunc();
   }
   if(condition1)
   {
       DFunc();
   }
}

可以看出在使用场景变多时间，均需要修改A模块，
显然不满足c语言"对拓展开放，对修改关闭的原则"，
因此采用了注册回调函数的方式，A模块提供了回调函数的接口，
根据需要做出对应实现即可

拿链表的查询函数来举例：

使用回调的方式来实现了不同数据的对应方法：

int findbyname(DATATYPE*data,void* arg)   //用于ModifyDouLinkList的回调
{
    return (0 == strcmp(data->name,(char*)arg));
}

int findbyage(DATATYPE*data,void* arg)  //用于ModifyDouLinkList的回调
{
    return data->age == *(int*)arg;
}

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(0==strcmp(tmp->data.name))
        if(fun(&tmp->data,arg))
        {
            return tmp;
        }
        tmp= tmp->next;
    }
    return NULL;
}

Final Strike

关注

5
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
数据结构（2）双向链表

线性表的链式存储解决顺序存储的缺点，插入和删除，动态存储问题。特点：线性表链式存储结构的特点是一组任意的存储单位存储线性表的数据元素，存储单元可以是连续的，也可以不连续。可以被存储在任意内存未被占用的位置上。所以前面的顺序表只需要存储数据元素信息就可以了。在链式结构中还需要一个元素存储下一个元素的地址。为了表示每个数据元素，ai与其直接后继数据元素ai+1之间的逻辑关系，对ai来说，除了存储其本身的信息外，还需要存一个指示器直接后续的信息。
复制链接

扫一扫