数据结构系列--双向链表

最新推荐文章于 2021-12-07 09:39:20 发布
最新推荐文章于 2021-12-07 09:39:20 发布
阅读量137 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36400704/article/details/108122983
版权

慧子和她的3D 慧子和她的3D 

单链表的局限：

  1. 单链表的结点都只有一个指向下一个结点的指针

    每个元素只知道后继结点是谁，不知道前驱结点

  2. 单链表的数据元素无法直接访问其前驱元素

  3. 逆向访问单链表中的元素是极其耗时的操作

    len = LinkList_Length(list);
for (i= len-1;len >= 0;i--)
{
  LinkListNode* p = LinkList_Get(list,i); //  访问数据元素p中的元素
}

     LinkList_Get 每次做循环找到需要返回的元素，复杂度是o（n^2）

        在单链表的结点中增加一个指向前驱的pre指针-->双链表

    前面留有习题，单链表进行逆序操作，算法复杂度为O(n)

        对于单链表逆序访问非常耗时，可以写一个时间算法复杂度为O(n)的操作，每次运算的时候转置一下：最后一个元素变成第一个元素，进行逆序操作，因为算法复杂度为O(n)，可以从原来的最后一个也就是现在的第一个进行访问，复杂度为O(n)访问结束。这里面逆序耗时很多，此时引入双向链表。

     

    将单链表代码改为双向链表工程名为：DLinkList.pro

    DLinkList.h

    #ifndef _DLINKLIST_H_
#define _DLINKLIST_H_

typedef void DLinkList;
typedef struct _tag_DLinkListNode DLinkListNode;
struct _tag_DLinkListNode
{
  DLinkListNode* Next;
  DLinkListNode* Pre;// 增加一个指向前驱数据元素的结点
}
DLinkList* DLinkList_Creat(int capacity);
void DLinkList_Destory(DLinkList* list);
void DLinkList_Clear(DLinkList* list);
int DLinkList_Length(DLinkList* list);
// int DLinkList_Capacity(DLinkList* list);
int DLinkList_Insert(DLinkList* list,DLinkListNode* node,int pos);
DLinkListNode* DLinkList_Get(DLinkList* list,int pos);
DLinkListNode* DLinkList_Delete(DLinkList* list,int pos);

#endif

    源文件

    #include <stdio.h>
#include <malloc.h>
#include "DlinkList.h"
// 头结点结构体
typedef struct _tag_DlinkList
{
int length//静态链表最多容纳多少元素
TDlinkListNode header;//链表头
}TDlinkList;

DlinkList* DlinkList_Create()//创建时指定静态链表的容量
{
  TDlinkList* ret = (TDlinkList*)malloc(sizeof(TDlinkList));
  
  if(ret != NULL)//指针不为0时可以继续赋值操作
  {
    ret->length = 0;//data作为静态链表表头表示长度
    ret->header.next = NULL;
    ret->header.pre = NULL;// 初始化的时候头结点的前向指针为空，即便不用也要初始化
  }
  
  return ret;
}

void DlinkList_Destory(DlinkList* list)
{
  free(list);
}

void DlinkList_Clear(DlinkList* list) 
{
  TDlinkList* sList = (TDlinkList*)list;//用到了数据封装，所以强制类型转换 
  if(sList !=NULL)//链表不为空是合法的，可以继续清空操作
  {
    sList->length = 0;
    sList->header.next = NULL;
    sList->header.pre = NULL;
  }
  
int DlinkList_Length(DlinkList* list)
{
  TDlinkList* sList = (TDlinkList*)list;//用到了数据封装，所以强制类型转换 
  int ret = -1;//定义一个返回值
  if(sList !=NULL)//链表不为空是合法的，可以继续清空操作
  {
    ret = sList->length;
  }
  return ret;
  }
  
int DlinkList_Insert(DlinkList* list,DlinkListNode* node,int pos)
{
  TDlinkList* sList = (TDlinkList*)list;//用到了数据封装，所以强制类型转换 
  int ret =(sList !=NULL) && (pos >=0) && (node != NULL)；//单链表方法完成判断
  int i=0；
  
  if(ret)//在数组中找空闲位置index
  {
    DlinkListNode* current = (DlinkListNode*)sList;
    DlinkListNode* next = NULL ;// 定义指针
    // 移动到插入位置
    for（i=0；(i<pos) && (current->next != NULL);i++）//后面是个保护动作，对于位置的保护，最多放在最后
      {
        current = current->next;//当前移动到下一个位置
      }
    next = current->next;
    
    current->next = node;
    node->next = next;
      // 新插入位置是双向链表第一个
    if(next != NULL)// 双向链表第一个元素的next不能为空，不然会与76行报错
        {
          next->pre = node;
        }
    node->pre = current;
    
    if (sLsit->length == 0)// 如果是个空链表插入第一个位置，那头结点要指向空
        {
          node->pre = NULL ;
        }
    sList->length++ ;
  
     }
  // 插入位置在头结点的位置比较特殊。pre需指向空
  return ret;
}

//由表头开始通过next域移动pos次后，当前元素的next域即要获取元素在数组中的下标
DlinkListNode* DlinkList_Get(DlinkList* list,int pos)
{
  TDlinkList* sList = (TDlinkList*)list;//用到了数据封装，所以强制类型转换 
  DlinkListNode* ret = NULL;//定义一个返回值
  
  int i = 0;
  if( (sList != NULL ) && (0 <= pos) && (pos < sList->length) )//链表不为空是合法的，长度正常
  {
      DlinkListNode* current =(DlinkListNode*)sList;
    
    for(i=0;i<pos;i++)
    {
      current = current->next;//第一个元素所在下标
    }
    
      ret = current->next;
  }
  return ret;
}

//获取第pos个元素，将第pos个元素从链表里删除
DlinkListNode* DlinkList_Delete(DlinkList* list,int pos)
{
  TDlinkList* sList = (TDlinkList*)list;//用到了数据封装，所以强制类型转换 
  DlinkListNode* ret = NULL;//定义一个返回值
  int i = 0;
  if( (sList !=NULL ) && (0 <= pos)&&(pos < sList->length )//链表不为空是合法的，长度正常
  {
    DlinkListNode* current = (DlinkListNode*)sList;
    DlinkListNode* next = NULL;
    // 找被删除元素
     for(i=0;i<pos;i++)
    {
      current = current ->next;//第一个元素所在下标
    }
    ret = current ->next;
    next = ret->next;// 被删除元素后继
    
    current ->next = next;
    // 被删除是最后一个元素
    if(next != NULL)
    {
      next->pre = current;
      // 被删元素是第一个
      if(current == (DlinkListNode*)sList)// 强制性修正，判断当前是否是表头
      {
        next->pre = NULL;
      }
   }
    sList->length--;

}

    main.c

    #include <stdio.h>
#include <stdlib.h>
#include "DlinkList.h"
struct Value
{
  DLinkListNode header;// 表头域
  int v;
};

int main(int argc,char *argv[])
{
int i = 0;
DlinkList* list =  DlinkList_Creat();
struct Value* pv = NULL;// 定义一个指针
// 定义
struct Value v1;
struct Value v2;
struct Value v3;
struct Value v4;
struct Value v5;
// 赋值
v1.v = 1;
v2.v = 2;
v3.v = 3;
v4.v = 4;
v5.v = 5;
// 最后一个元素后面插入
DlinkList_Insert(list,(DLinkListNode*)&v1,DLinkList_Length(list));
DlinkList_Insert(list,(DLinkListNode*)&v2,DLinkList_Length(list));
DlinkList_Insert(list,(DLinkListNode*)&v3,DLinkList_Length(list));
DlinkList_Insert(list,(DLinkListNode*)&v4,DLinkList_Length(list));
DlinkList_Insert(list,(DLinkListNode*)&v5,DLinkList_Length(list));
for(i = 0;i <DlinkList_Length(list);i++)
  {// 调用get来取元素
    pv = (struct Value*)DlinkList_Get(list,i);
    printf("%d\n",pv->v);
  }

printf("\n");
// 删除第一个和最后一个元素
DlinkList_Delete(list,DlinkList_Length(list)-1;);
DlinkList_Delete(list,0);

DlinkList_Destroy(list);

return 0;
}

     

    双向链表新操作

    DLinkList.h

    #ifndef _DLINKLIST_H_
#define _DLINKLIST_H_

typedef void DLinkList;
typedef struct _tag_DLinkListNode DLinkListNode;
struct _tag_DLinkListNode
{
  DLinkListNode* Next;
  DLinkListNode* Pre;// 增加一个指向前驱数据元素的结点
}
DLinkList* DLinkList_Creat(int capacity);
void DLinkList_Destory(DLinkList* list);
void DLinkList_Clear(DLinkList* list);
int DLinkList_Length(DLinkList* list);
// int DLinkList_Capacity(DLinkList* list);
int DLinkList_Insert(DLinkList* list,DLinkListNode* node,int pos);
DLinkListNode* DLinkList_Get(DLinkList* list,int pos);
DLinkListNode* DLinkList_Delete(DLinkList* list,int pos);
// 引进游标新操作
DLinkListNode* DLinkList_DeleteNode(DLinkList* list,DLinkListNode* node);
DLinkListNode* DLinkList_Current(DLinkList* list);
DLinkListNode* DLinkList_Next(DLinkList* list);
DLinkListNode* DLinkList_Pre(DLinkList* list);
#endif

    源文件

    #include <stdio.h>
#include <malloc.h>
#include "DlinkList.h"

#define AVAILABLE -1//空闲位置的宏
//链表结构体定义
typedef struct _tag_DlinkList
{
int length;//静态链表最多容纳多少元素
TDlinkListNode header;//链表头
TDlinkListNode slider;//游标
}TDlinkList;

DlinkList* DlinkList_Create()//创建时指定静态链表的容量
{
  TDlinkList* ret = (TDlinkList*)malloc(sizeof(TDlinkList));
  
  if(ret != NULL)//指针不为0时可以继续赋值操作
  {
    ret->length = 0;//data作为静态链表表头表示长度
    ret->header.next = NULL;
    ret->header.pre = NULL;// 初始化的时候头结点的前向指针为空，即便不用也要初始化
    ret->slider = NULL;
  }
  
  return ret;
}

void DlinkList_Destory(DlinkList* list)
{
  free(list);
}

void DlinkList_Clear(DlinkList* list) 
{
  TDlinkList* sList = (TDlinkList*)list;//用到了数据封装，所以强制类型转换 
  if(sList !=NULL)//链表不为空是合法的，可以继续清空操作
  {
    sList->length = 0;
    sList->header.next = NULL;
    sList->header.pre = NULL;
    ret->slider = NULL;
  }
  
int DlinkList_Length(DlinkList* list)
{
  TDlinkList* sList = (TDlinkList*)list;//用到了数据封装，所以强制类型转换 
  int ret = -1;//定义一个返回值
  if(sList !=NULL)//链表不为空是合法的，可以继续清空操作
  {
    ret = sList->length;
  }
  return ret;
  }
  
int DlinkList_Insert(DlinkList* list,DlinkListNode* node,int pos)
{
  TDlinkList* sList = (TDlinkList*)list;//用到了数据封装，所以强制类型转换 
  int ret =(sList !=NULL) && (pos >=0) && (node != NULL)；//单链表方法完成判断
  int i=0；
  
  if(ret)//在数组中找空闲位置index
  {
    DlinkListNode* current = (DlinkListNode*)sList;
    DlinkListNode* next = NULL ;// 定义指针
    // 移动到插入位置
    for（i=0；(i<pos) && (current->next != NULL);i++）//后面是个保护动作，对于位置的保护，最多放在最后
      {
        current = current->next;//当前移动到下一个位置
      }
    next = current->next;
    
    current->next = node;
    node->next = next;
      // 新插入位置是双向链表第一个
    if(next != NULL)// 双向链表第一个元素的next不能为空，不然会与76行报错
        {
          next->pre = node;
        }
    node->pre = current;
    
    if (sLsit->length == 0)// 如果是个空链表插入第一个位置，那头结点要指向空
        {
          node->pre = NULL ;
          sLsit->slider = node;// 将链表中游标指向第一个元素
        }
    sList->length++ ;
  
     }
  // 插入位置在头结点的位置比较特殊。pre需指向空
  return ret;
}

//由表头开始通过next域移动pos次后，当前元素的next域即要获取元素在数组中的下标
DlinkListNode* DlinkList_Get(DlinkList* list,int pos)
{
  TDlinkList* sList = (TDlinkList*)list;//用到了数据封装，所以强制类型转换 
  DlinkListNode* ret = NULL;//定义一个返回值
  
  int i = 0;
  if( (sList != NULL ) && (0 <= pos) && (pos < sList->length) )//链表不为空是合法的，长度正常
  {
      DlinkListNode* current =(DlinkListNode*)sList;
    
    for(i=0;i<pos;i++)
    {
      current = current->next;//第一个元素所在下标
    }
    
      ret = current->next;
    }
  return ret;
}

//获取第pos个元素，将第pos个元素从链表里删除
DlinkListNode* DlinkList_Delete(DlinkList* list,int pos)
{
  TDlinkList* sList = (TDlinkList*)list;//用到了数据封装，所以强制类型转换 
  DlinkListNode* ret = NULL;//定义一个返回值
  int i = 0;
  if( (sList !=NULL ) && (0 <= pos)&&(pos < sList->length )//链表不为空是合法的，长度正常
  {
    DlinkListNode* current = (DlinkListNode*)sList;
    DlinkListNode* next = NULL;
    // 找被删除元素
     for(i=0;i<pos;i++)
      {
        current = current ->next;//第一个元素所在下标
      }
    ret = current ->next;
    next = ret->next;// 被删除元素后继
    
    current ->next = next;
    // 被删除是最后一个元素
    if(next != NULL)
      {
        next->pre = current;
        // 被删元素是第一个
        if(current == (DlinkListNode*)sList)// 强制性修正，判断当前是否是表头
          {
            next->pre = NULL;
          }
       }
   // 里面只有一个元素被删除
   if(sList->slider == ret)// 删除元素是不是游标指向元素
     {
       sList->slider == next;// 移动游标指向下一个元素
     }
    sList->length--;
   }
return ret;
}
// 引进游标新操作
DLinkListNode* DLinkList_DeleteNode(DLinkList* list,DLinkListNode* node)
{
  TDlinkList* sList = (TDlinkList*)list;//用到了数据封装，所以强制类型转换 
  DlinkListNode* ret = NULL;//定义一个返回值
  int i = 0;
  // 查找删除元素
  if(sList !=NULL ) 
  {
    DlinkListNode* current = (DlinkListNode*)sList;
    // 找被删除元素
     for(i=0;i<sList->length;i++)
      {
        if(current ->next == node)
          {
            ret = current ->next;
            break;
          }
        current  = current ->next;
      }
    if(ret != NULL)// 没找到
      {
        DlinkList_Delete(sList,i);
      }
   // 里面只有一个元素被删除
   if(sList->slider == ret)// 删除元素是不是游标指向元素
       {
         sList->slider == next;// 移动游标指向下一个元素
       }
 }
    sList->length--;
   }
return ret;
}
// 游标相关操作
DLinkListNode* DLinkList_Current(DLinkList* list)
{
 TDlinkList* sList = (TDlinkList*)list;//用到了数据封装，所以强制类型转换 
  DlinkListNode* ret = NULL;//定义一个返回值
  
  if(sList !=NULL)//链表不为空是合法的，可以继续清空操作
    {
      ret->sList->slider ;
    }
    
}
DLinkListNode* DLinkList_Next(DLinkList* list)
{
  TDlinkList* sList = (TDlinkList*)list;//用到了数据封装，所以强制类型转换 
  DlinkListNode* ret = NULL;//定义一个返回值
  
  if ((sList !=NULL) && (sList->slider != NULL))//链表不为空是合法的，可以继续清空操作
  {
    ret->sList->slider ;
    sList->slider = ret->next;
  }
}
DLinkListNode* DLinkList_Pre(DLinkList* list)
{
  TDlinkList* sList = (TDlinkList*)list;//用到了数据封装，所以强制类型转换 
  DlinkListNode* ret = NULL;//定义一个返回值
  
  if(sList !=NULL)//链表不为空是合法的，可以继续清空操作
  {  
    ret->sList->slider ;
    sList->slider = ret->pre;// 指向当前前一个
  }
}

    main.c

    #include <stdio.h>
#include <stdlib.h>
#include "DlinkList.h"
struct Value
{
  DLinkListNode header;// 表头域
  int v;
};

int main(int argc,char *argv[])
{
int i = 0;
DlinkList* list =  DlinkList_Creat();
struct Value* pv = NULL;// 定义一个指针
// 定义
struct Value v1;
struct Value v2;
struct Value v3;
struct Value v4;
struct Value v5;
// 赋值
v1.v = 1;
v2.v = 2;
v3.v = 3;
v4.v = 4;
v5.v = 5;
// 最后一个元素后面插入
DlinkList_Insert(list,(DLinkListNode*)&v1,DLinkList_Length(list));
DlinkList_Insert(list,(DLinkListNode*)&v2,DLinkList_Length(list));
DlinkList_Insert(list,(DLinkListNode*)&v3,DLinkList_Length(list));
DlinkList_Insert(list,(DLinkListNode*)&v4,DLinkList_Length(list));
DlinkList_Insert(list,(DLinkListNode*)&v5,DLinkList_Length(list));
for(i = 0;i <DlinkList_Length(list);i++)
  {// 调用get来取元素
    pv = (struct Value*)DlinkList_Get(list,i);
    printf("%d\n",pv->v);
  }

printf("\n");
// 删除第一个和最后一个元素
DlinkList_Delete(list,DlinkList_Length(list)-1;);
DlinkList_Delete(list,0);
for(i = 0;i <DlinkList_Length(list);i++)
  {// 调用get来取元素
    pv = (struct Value*)DlinkList_Next(list);
    printf("%d\n",pv->v);
  }
  printf("\n");
  DlinkList_Resert(list);// 游标指向第一个元素
  DlinkList_Next(list);// 游标向后移一个指向位置2
  pv = (struct Value*)DlinkList_Current(list);
  printf("%d\n",pv->v);
  // 删除当前元素
  DlinkList_DeleteNode(list,( DlinkLisNode*)pv);
  pv = (struct Value*)DlinkList_Current(list);
  printf("%d\n",pv->v);
  
  DlinkList_Pre(list);
  pv = (struct Value*)DlinkList_Current(list);
  printf("%d\n",pv->v);
  printf("Length : %d\n",DlinkList_Length(list));
  
  DlinkList_Destroy(list);

return 0;
}

    小结：

    双向链表在单链表的基础上增加了指向前驱的指针

    功能上双向链表可以取代单链表的使用

    循环链表的NEXT PRE CURRENT操作可以高效的遍历链表中所有元素

殇沐
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单向链表改双向链表
宇宙观光巴士站
12-05 2700
单向链表改双向链表 -数据结构题目 （原题来自严蔚敏老师教材习题册2.32） 题目：已知有一个单向循环链表，其每个结点中含三个域：prior,data和next，其中data为数据域，next为指向后继结点的指针域，prior也为指针域，但它的值为空（NULL），试编写算法将此单向循环链表改为双向循环链表，即使prior成为指向前驱结点的指针域。 算法思想：先建立一个单链表，然后写一个函数，将prior指针指向它的前驱元素即可完成修改。 c++代码如下： #include <iostream>
c语言链表怎么输出第n个元素,c语言的双链表问题,请问如何才能正确输出双链表元素。...
weixin_35385462的博客
05-23 407
匿名用户1级2008-08-09 回答我做过的作业给你，可以直接运行#include#include#define NULL 0#define LEN sizeof(struct DuLNode)typedef struct DuLNode{ int data;struct DuLNode* prior;struct DuLNode* next;}DuLNode,*DuLinkList;void ...
单向链表转换为双向循环链表
见习馒头
09-18 3276
1、单向链表转换为双向循环链表 已知 struct lknode{ int data; struct lknode *next; }*lkhead; lkhead是单向链表的头指针； struct dbnode{ int data; struct dbnode *prior, *next; } *dbhead; 需实现的函数接口为struct *dbnode doubleli
C语言之——链表（二）
wwwlyj123321的博客
09-09 395
一、单链表的局限性 (1) 单链表各个节点之间只由一个指针单向链接，这样实现有一些局限性。局限性主要体现在单链表只能经由指针单向移动（一旦指针移动过某个节点就无法再回来，如果要再次操作这个节点除非从头指针开始再次遍历一次），因此单链表的单向移动性导致我们在操作单链表时，当前节点只能向后移动不能向前移动，因此不自由，不利于解决更复杂的算法。 (2) 解决思路： 双向链表的节点 = 有效数据 +...
高级数据结构与算法 | 跳跃表（Skip List）
凌桓丶的博客
09-09 1143
文章目录区间查询时链表与顺序表的局限跳表=链表+索引跳表的原理晋升插入删除跳表的实现跳表VS红黑树 区间查询时链表与顺序表的局限 假设有这样一个情景， 此时需要设计一个拍卖系统，对于商品的展示需要支持按照价格、销量、好评、拍卖人编号等方式进行排序，并且还需要支持按照名字的精确查询以及不需要名字的全量查询。 拍卖行商品的列表是线性的，那么首选的数据结构应该就是线性结构中的链表和顺序表。 假设此时是一个按照价格进行排序的集合 如果此时使用的是一个顺序表，当有商品插入时首先就要确认其插入的位置，因为顺序表支持下
链表-使用PHP实现的双向链表数据结构.zip
03-13
在本案例中，"链表-使用PHP实现的双向链表数据结构.zip" 是一个压缩文件，其中包含了一个使用PHP语言实现的双向链表数据结构的示例。双向链表是链表的一种变体，与单向链表不同，它允许从两个方向遍历链表。每个节点...
数据结构-链表.pdf
最新发布
04-15
数据结构-链表 单向链表，双向链表、循环链表等
数据结构-双向链表
04-14
双向链表是一种特殊的数据结构，它在编程中具有重要的应用。本文将深入探讨双向链表的概念，实现，以及如何进行基本操作。 双向链表，顾名思义，是一种链式存储结构，其中每个节点包含两个指针，一个指向前一个节点...
数据结构-链表的C语言使用
03-25
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。在C语言中，链表不像是数组那样在内存中连续存储元素，而是通过一系列分散的内存块（称为节点）来表示数据。每个...
单链表改为双向循环链表
Blog
01-11 3512
package Linear; /* * 将单链表（结点有2个域pre，next，pre为空）改为双向循环链表 */ public class I { public static void doubleDirection(Node h) { Node p =h.next; Node pre =h; while (p!=null) { p.pre=pre; p=p.n...
c/c++ 循环单链表变循环双链表
weixin_40971308的博客
05-13 2865
最近遇到了一个作业题目是：建立一个循环单链表，其节点有 prior，data 和 next 三个域，其中 data 为数据域，存放元素的有效信息，next 域为指针域，指向后继节点，prior 为指针域，它的值为 NULL。编写一个算法将此表改为循环双链表。看了一下感觉不难，好，开始动手。建立链表结构 链表在c语言建立是通过结构体建立，通过在结构体内部建立其结构体本身的指针类型指向下一个节点来实现...
单链表改为双链表
Just Play
10-27 2004
/*--------------单链表改为双链表-----------*/#include #define  ok 1#define  error 0typedef int elemtype;typedef struct lnode{ lnode *pre; lnode *next; elemtype data;} lnode,*linklist;bool createlist(linklis
浅谈单链表与双链表的区别
热门推荐
kangxidagege的博客
05-06 7万+
昨天面试官面试的时候问了我一道关于链表的问题：情境如下 面试官：请说一下链表跟数组的区别？ 我：数组静态分配内存，链表动态分配内存；数组在内存中连续，链表不连续；数组利用下标定位，时间复杂度为O(1)，链表定位元素时间复杂度O(n)；数组插入或删除元素的时间复杂度O(n)，链表的时间复杂度O(1)。 根据以上分析可得出数组和链表的优缺点如下：   数组的优点 随机访问性强（通过下标进行...
单链表和双链表
m0_62097996的博客
12-02 644
在这里有一个线性表的感念。线性表是N个类型相同数据元素的有限序列，N>0，除第一个元素没有前驱，最后一个元素没有后继之外，其余元素都只有一个前驱和一个后继。线性表一般表示为：（a1,a2,a3,...an）这些数据之间是一对一的关系。 线性表的特点：1.表中元素的个数有限，2.表中元素具有逻辑上的顺序性，3.表中元素都是数据元素，每个元素都是单个元素，4.表中元素的数据型都相同，每个元素占有相同大小的存储空间，5.表中元素具有抽象性（仅讨论元素箭的逻辑关系，而不考虑元素究竟表示什么内容）。 .
单链表和双链表的区别
天射手座的博客
01-23 9562
一、方向不同 单链表只有指向下一个结点的指针 双链表既有指向下一个结点的指针，也有指向上一个结点的指针 二、适用情况不同 单向链表更适合元素的增加与删除 双向链表更适合元素的查询工作 三、读取不同 单链表只能单向读取 双链表可以双向读取 ...
把单循环链表改为双循环链表
进阶的小宋
12-07 1333
将单链表拆分为两个特定的单链表
yfainaer的专栏
09-22 9329
将一个给定的单链表拆分为两个特定的单链表
数据结构第一谈：单链表双向链表的实现（基于Java）
小游子YKY的博客
01-06 2648
单链表 双向链表 基于Java的单链表双向链表实现

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值