紧凑的多重数组的静态双向链表实现

最新推荐文章于 2023-05-25 22:55:39 发布
最新推荐文章于 2023-05-25 22:55:39 发布
阅读量2.4k 收藏 6
点赞数 1
分类专栏： 《算法导论》
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z84616995z/article/details/20291697
版权

相关问题：

              我们往往希望双向链表的所有元素在存储器中保持紧凑，例如，在多数组表示中占用前m个下标位置.(在页式虚拟存储的计算环境下，即为这种情况。)假设除指向链表本身的指针外没有其他指针指向该链表元素，试说明如何实现过程ALLOCATE-OBJECT和FREE-OBJECT，使得该表示保持紧凑。(提示，使用栈的数组实现)。

思考过程：

              如果当前数组是紧凑的，设数组已经有n个数据，位于数组前n个位置（栈顶指针为n）。插入一个元素时，需要分配空间，那么栈顶指针+1，也就是第n+1个位置分配给新元素。删除一个元素时，如果删除的元素下标小于栈顶，那么删除后释放内存时，需要把栈顶元素填充到原删除元素的下标位置处，栈顶指针-1,使之保持紧凑。如果删除的元素下标等于栈顶时（按照题意，在分配和释放内存时一定总是保持紧凑的，所以数组中始终是前面的连续空间有数据并且最多不会超过栈顶下标位置，如果超过了就不是紧凑的链表，所以不会出现大于栈顶的情况）那么直接删除，栈顶下标-1即可。

代码如下：

//10.3-4紧凑的多数组静态双向链表
#include <iostream>
#include <time.h>
using namespace std;
#define MAX 10//于表头的前驱和表尾的后继都不存放元素，所以实际能存放的有效元素个数比MAX少2个
#define Null -1
int head=-1,Free=0;
struct List
{
    int next[MAX];
    int key[MAX];
    int prev[MAX];
    int top;
};
//链表初始化
void Initialization(struct List &T)
{
   for (int i=0;i<MAX;i++)
   {
       T.key[i]=0;
       T.prev[i]=0;
   }
   int p=head;
   for ( i=0;i<MAX-1;i++)
   {
      T.next[i]=i+1;
   }
   T.next[i]=Null;//链表最后的next指针为空。-1代表空
   T.top=Null;
}  
//分配空间
int Allocate_object(struct List &T)
{
    static x=0;
    if (Free==MAX)
    {
        cout<<endl;
        cerr<<"out of space!"<<endl;
        return Null;
    }
    else
    {   
        T.top++;//分配空间时，先增加栈顶上限。
        x=T.top;
        Free=T.top+1;//Free指向栈顶下一个位置
        return x;
    }
}
//释放空间
void Free_object(struct List &T,int x)
{//释放空间时，为了使数组紧凑，所以待删除x小于栈顶T.top，那么就需要把删除后的x空位用栈顶位置的数据填充上，
 //这样小于栈顶的位置全部都有有效数据，从而使数据更紧凑。
    if (x<T.top)
    {
        T.key[x]=T.key[T.top];
        //if (T.next[T.top]!=x)//这个判断我还不清楚是否有必要，如果程序出错，加上这个判断试试
        //{
            T.next[x]=T.next[T.top];
        //}
        //if(T.prev[T.top]!=x)//同上
        //{
            T.prev[x]=T.prev[T.top];
        //}
        T.prev[T.next[x]]=x;
        T.next[T.prev[x]]=x;
        if (head==T.top)
        {
            head=x;
        }
    }
    T.top--;Free--;
}
//插入数据
void insert(struct List &T,int k)
{
    int x=Allocate_object(T);//类似指针开辟一段内存空间
    if (x==Null)
    {
        return ;
    }
    T.next[x]=head;
    T.key[x]=k;
    if (head!=Null)
    {
        T.prev[head]=x;
    }
    head=x;
    T.prev[x]=Null;
}
//查找数据
int search(struct List &T,int k)
{
   int t=head;
   if (T.key[t]==0)
   {
       cout<<"链表为空！无法查找！"<<endl;
       return Null;
   }
   while (t!=-1&&T.key[t]!=k)
   {
       t=T.next[t];
   }
   if (t==Null)
   {
       cout<<"不存在这个数据！"<<endl;
       return Null;
   } 
   else
   {
      cout<<"待查找数据已经找到！"<<endl;
      return t;//将待删除的数据下标返回，易于删除工作。
   }
}
//删除数据
void Delete(struct List &T,int k)//删除特定值的删除函数
{ 
    int p=0;
        p=search(T,k);
        if (p!=Null)
        {
       
            if (T.prev[p]!=Null)
            {
                T.next[T.prev[p]]=T.next[p];
            } 
            else
            {
                head=T.next[p];
            }
            if (T.next[p]!=Null)
            {
                T.prev[T.next[p]]=T.prev[p];
            }
            cout<<"删除成功！"<<endl;
            Free_object(T,p);
        } 
        else
        {
            cout<<"待删除的数据不存在！无法删除！"<<endl;
        }
}
void Print(struct List &T)
{
    int i=head;
    if (head==Null)
    {
        cout<<"此链表为空！"<<endl;
        return;
    }
    while (T.next[i]!=Null/*&&T.key[i]!=NULL*/)
    {
        cout<<T.key[i]<<"->";
        i=T.next[i];
    }
    cout<<T.key[i]<<" ";
    cout<<endl;
}
void main()
{
    struct List T;
    srand((unsigned)time(NULL));
    int num[MAX]={0};//临时存放next[MAX]数组的值，目的是用于生成互异的随机数
    cout<<"初始化链表中。";
    int NUM[MAX]={0};//用于存放循环插入的随机数据，便于删除。
    Initialization(T);
    Print(T);
    for (int i=0;i<=MAX;i++)
    {
        int k=rand()%100;
        NUM[i]=k;
        insert(T,k);
    }
    Print(T);
    for ( i=0;i<MAX;i++)
    {
        Delete(T,NUM[i]);
    }
    Print(T);
    insert(T,34);
    insert(T,56);
    insert(T,3);
    insert(T,13);
    Delete(T,34);
    Print(T);
    insert(T,18);
    insert(T,23);
    Delete(T,3);
    Delete(T,18);
    Delete(T,100);
    insert(T,25);
    insert(T,16);
    Delete(T,23);
    Print(T);    
}

类似问题：

                     设L是一个长度为n的双向链表，存储于长度为m的数组key,prev和next中。假设这些数组由维护双链自由表F的两个过程ALLOCATE-OBJECT和FREE-OBJECT进行管理。又假设m个元素中，恰有n个元素在链表L上，m-n个在自由表上。给定链表L和自由表F，试写出一个过程COMPACTIFY-LIST(L,F),用来移动L的元素使其占用数组中1,2，。。。n的位置，调整自由表F以保持其正确性，并且占用数组中n+1,n+2....,m的位置。要求缩写的过程运行时间应为 θ(n)，且只使用固定量的额外存储空间。请证明所写的过程是正确的。

思考过程：           

                将要编写的COMPACTIFY-LIST(L,F)函数就是以上面的代码中的FREE-OBJECT函数做为代码的一部分，然后首先查找自由表前n个位置的空位置，用临时数组保存起来，然后在把所有下标大于n的链表L中的元素与其交换，使得前n个元素所有位置都被填充上数据。这样原本不紧凑的链表变得紧凑了

//10.3-5写一个函数，使原本不紧凑的链表变得紧凑
#include <iostream>
#include <time.h>
#include <windows.h>
using namespace std;
#define MAX 20//于表头的前驱和表尾的后继都不存放元素，所以实际能存放的有效元素个数比MAX少2个
#define Null -1
int head=Null,Free=0;
int j=0;int n=0;
struct List
{
    int next[MAX];
    int key[MAX];
    int prev[MAX];
};
int isIn(int *num,int index,int pat)//生成的随机数pat是否已经存在
{
    int i=0;
    for(i=0;i<index;++i)
        if(pat==num[i])
            return 1;
        return 0;   
}
int RAND(int *num)//随机抽取元素互异的key 这样key不会出现重复数值，易于以后的删除工作。
{
    int result=0;
    if (j>=MAX)
    {
        return Null;
    }
    while(1)
    {
        result=rand()%MAX;
        if(!isIn(num,j,result))
        {
            num[j]=result;
            j++;
            break;
        }
    }
    return result;
}
//链表初始化
void Initialization(struct List &T,int*num)
{
   Free=RAND(num);//[1,MAX-1]之间的数随机选择一个作为表头元素下标
   for (int i=0;i<MAX;i++)
   {
       T.key[i]=0;
       T.prev[i]=0;
   }
   int p=Free;
   for ( i=0;i<MAX-1;i++)
   {
       p=T.next[p]=RAND(num);
   }
   T.next[p]=Null;//链表最后的next指针为空。-1代表空
   j=0;//结构体T初始化后，临时数组num下标设置为0.
}  
//分配空间
int Allocate_object(struct List &T,int*num)
{
    if (Free==Null)
    {
        cerr<<"out of space!"<<endl;
        return Null;
    }
    else
    {    
      int x=Free; 
	  Free=T.next[x];
      return x;
    }
}
//释放空间
void Free_object(struct List &T,int x)
{
   T.next[x]=Free;
   Free=x;
   n--;
}
//插入数据
void insert(struct List &T,int k,int *num)
{
     int x=Allocate_object(T,num);//类似指针开辟一段内存空间
	 if (x==Null)
	 {
		 return;
	 }
	 T.next[x]=head;
	 T.key[x]=k;
	 if (head!=Null)
	 {
		 T.prev[head]=x;
	 }
	 head=x;
	 T.prev[x]=Null;
     n++;
}
//查找数据
int search(struct List &T,int k)
{
   int t=head;
   if (head==Null)
   {
       cout<<"链表为空！无法查找！"<<endl;
       return Null;
   }
   while (t!=-1&&T.key[t]!=k)
   {
       t=T.next[t];
   }
   if (t==Null)
   {
       cout<<"不存在这个数据！"<<endl;
       return Null;
   } 
   else
   {
      cout<<"待查找数据已经找到！"<<endl;
      return t;//将待删除的数据下标返回，易于删除工作。
   }
}
//删除数据
void Delete(struct List &T,int k)//删除特定值的删除函数
{ 
    int p=0;
        p=search(T,k);
        if (p!=Null)
        {
       
            if (T.prev[p]!=Null)
            {
                T.next[T.prev[p]]=T.next[p];
            } 
            else
            {
                head=T.next[p];
            }
            if (T.next[p]!=Null)
            {
                T.prev[T.next[p]]=T.prev[p];
            }
			T.key[p]=0;//设置为0做为一个标志，表明这个位置为空。完全可以设置其他数字作为标志。这里的0起到的是标志符号作用
            cout<<"删除成功！"<<endl;
            Free_object(T,p);
        } 
        else
        {
            cout<<"待删除的数据不存在！无法删除！"<<endl;
        }
}
void Compactify_list(struct List &T)
{
	int i=0,k=0;
	int temp[MAX]={0};
	while (i!=n)//O(n)
	{
		if (T.key[i]==0)//由于删除后，我们把其设置为0这个标志，那么根据标志判断前n个位置哪些是空的，哪些是非空的。
		{
           temp[k]=i;//如果是空值，那么记录下来保存到临时数组中。
		   k++;
		}
		i++;
	}
	int p=head,j=0;
	while (p!=Null)//O(n)
	{
		if (p>=n)
		{
			T.key[temp[j]]=T.key[p];
			T.next[temp[j]]=T.next[p];
			T.prev[temp[j]]=T.prev[p];
			T.prev[T.next[temp[j]]]=temp[j];
			T.next[T.prev[temp[j]]]=temp[j];
			if (head==p)
			{
				head=temp[j];
			}
			j++;
		}
        p=T.next[p];
	}
}
void Print(struct List &T)
{
    int i=head;
    if (head==Null)
    {
        cout<<"此链表为空！"<<endl;
        return;
    }
    while (i!=Null)
    {
        cout<<T.key[i]<<"->";
        i=T.next[i];
    }
    cout<<endl;
}
void main()
{
    struct List T;
    srand((unsigned)time(NULL));
    int num[MAX]={0};//临时存放next[MAX]和key[MAX]数组的值，目的是用于生成互异的随机数
    cout<<"初始化链表中。"; 
    Initialization(T,num);
    Print(T);
    cout<<"给链表添加数据中。"; 
    insert(T,35,num);
	insert(T,53,num);
	insert(T,65,num);
	insert(T,78,num);
    insert(T,13,num);
	insert(T,2,num);
	insert(T,5,num);
	insert(T,7,num);
	insert(T,18,num);
	insert(T,15,num);
    Print(T);
    cout<<"查找数据中。"; 
    search(T,53);
    cout<<"删除数据中。"; 
    Delete(T,65);
    Delete(T,2);
	Delete(T,5);
	Delete(T,500);
	Delete(T,78);
	insert(T,25,num);
	Print(T);
	Compactify_list(T);
	Print(T);
}

以上代码属于原创，并且经过大量数据验证暂时没有错误，如果各位大牛发现其中有误，请联系我。谢谢！




Flammable_ice
关注
专栏目录
进BAT必懂：大厂高频八股文面试题及参考答案（6万字长文）
大模型大数据攻城狮的专栏
07-31 417
目录 解释 Java 中的自动装箱和拆箱机制，并举例说明。 自动装箱与拆箱机制 注意事项 简述 Java 中的异常处理机制，包括 try-catch-finally 结构的使用。 异常处理机制 谈谈 Java 中的访问修饰符（public、private、protected、default）的作用范围和使用场景。 访问修饰符 使用场景 什么是 Java 的注解？列举一些常见的注解并说明其用途。 Java 注解 常见注解 描述 Java 中的对象克隆（Object Cloning）
50个数据结构案例及详细步骤分析 - C语言版
csdn_tuijian的博客
01-26 1万+
第1章　数据结构基础 结构之美无处不在 说到结构，任何一件事物都有自己的结构，就如可以看得见且触摸得到的课桌、椅子，还有看不见却也存在的分子、原子。可见一件事物只要存在，就一定会有自己的结构。一幅画的生成，画家在挥毫泼墨之前，首先要在数尺素绢之上做结构上的统筹规划、谋篇布局；一件衣服的制作，如果在制作之前没有对衣服的袖、领、肩、襟、身等各个部位周密筹划，形成一个合理的结构系统，便无法缝制出合体的衣服；还有教育管理系统的结构、通用技术的学科结构、课堂教学结构等。试想一下，管理大量数据是否也需要数据结构呢？
C语言数组型双向链表的处理
08-26
ALIST是一段基于C语言的数组型双向链表的处理代码，接口简单明了，易于使用，标准C语言开发，可添加在任何C/C++语言工程中，需要注意的是，如果使用了操作系统，请自行在库中修改指向处添加资源锁定，避免因操作系统的切换，造成的链表错误的问题。 ALIST.rar文件包包含了ALIST库文件及基本测试代码，使用了CLion开发工具，有CLion工程文件，下载后可直接打开运行测试。 库文件若有错误或其他优化点，请评论指出，谢谢。
数组模拟双链表
qq_52765554的博客
05-23 347
题目链接: AcWing 827. 双链表 . 代码参考链接: 点击这里. 实现一个双链表，双链表初始为空，支持 5 种操作： 在最左侧插入一个数； 在最右侧插入一个数； 将第 k 个插入的数删除； 在第 k 个插入的数左侧插入一个数； 在第 k 个插入的数右侧插入一个数 现在要对该链表进行 M 次操作，进行完所有操作后，从左到右输出整个链表。 注意:题目中第 k 个插入的数并不是指当前链表的第 k 个数。例如操作过程中一共插入了 n 个数，则按照插入的时间顺序，这 n 个数依次为：第 1 个插入的数，第
数组实现双链表
RJ_theMag的博客
07-16 760
之前写了数组实现单链表，提到了数组实现链表比指针实现最大的优点就是快，可以随机存取，而且不用new节点。 在图论的题目里用到邻接表，往往都是用数组实现。 数组实现双链表比单链表就多了一些对于左指针的操作。 为了实现的方便，不像在单链表实现里用一个额外的变量head去记录链表的头节点。 而是直接用两个哨兵节点固定为双链表的头节点和尾节点。 我们可以固定头节点为0，尾节点为1. 也就是说，0的right指针指向链表的第一个节点，1的left指针指向链表的第一个节点。 这样，0和1就被固定为头节点和尾节点了。我们
【转载】多重数组实现双向链表
zhangmengjlu的专栏
04-22 543
有些语言不提供指针与对象数据类型，以下代码通过多重数组实现链表结构及其基本操作。 用一个数组空间模拟分配堆。用一个头指针为free的链表来管理自由空间。用栈得push和pop操作来实现释放和分配空间。 三个数组next，key和prev分别存储关键字以及指针 以下是代码 /* Description：在没有显式的指针数据类型时实现双向链表数据结构 Date：2012/10/7
数组实现双向链表、双向链表的操作
qq_40823802的博客
08-13 1888
分析： 思路： 遍历：和单链表一样，只是可以向前，也可以向后查找。 添加（默认添加到双向链表的最后） （1）.先找到双向链表的最后这个节点（temp） （2）.temp.next = newHeroNode （3）.newHeroNode.pre = temp; 修改思路和单链表一样 删除 （1）.以为是双向链表，因此，我们可以实现自我删除某个节点 （2）.直接找到要删除的这个节点，比...
《Gpu Gems》《Gpu Pro》《Gpu Zen》系列读书笔记
热门推荐
puppet_master的专栏
02-13 2万+
本篇blog简单记录了一下最近一两年一直在读的一系列书目。《Gpu Gems》1-3三部，《Gpu Pro》1-7七部，《Gpu Zen》一部。针对每一项渲染技术，进行全系列书的总结，从这个角度来看，可以看到一项技术，近十五六年来的进化过程。
Java知识点概览
qq_48403611的博客
08-03 3509
java后端开发常见面试题总结
算法导论第十章基本数据结构
z84616995z的专栏
02-14 5537
10.1栈与队列 （1） 栈 概念定义：栈属于动态集合，采用先进后出策略（LIFO）。基本操作是压入（PUSH）和弹出（POP）。如果s.top=0，表示栈空，如果试图对空栈进行POP操作会发生下溢（underflow）。如果s.top>n,表示栈满，如果进行PUSH操作会发生上溢（overflow）。 基本代码： //基本的栈操作 #include #include using na
（数组模仿双向链表）Boxes in a Line
black_horse2018的博客
02-24 485
给定N个盒子，从左到右分别标号为1~N；有下面4种操作： “1 X Y” 表示将编号为X的盒子移到编号为Y的左边； “2 X Y” 表示将编号为X移到编号为Y的右边； “3 X Y” 表示交换编号为X和Y的位置； “4” 表示将1~N所有的盒子反序。 要你求经过M次操作之后，所有奇数位置的盒子标号之和。 For example, if n = 6, after executing 1 1 4, t...
用对象的多重数组实现双链表
V然成风
01-30 1258
在有些语言（例如FORTRAN）中不提供指针与对象数据类型，那么该如何实现双链表呢？我们将介绍运用数组和数组下标在逻辑上来构造双链表，让它表现的就像用指针实现的一样自然。 对象的多重数组表示    如下图是一个用数组实现的双链表的逻辑图：    对一组具有相同域的对象，每一个域都可以用一个数组来表示。上图说明了如何用三个数组实现双链表。动态几何的关键字存储在数组key中，而指针域
用数组模拟双向链表
＃ｉｎｃｌｕｄｅ＜Excelsior＞
08-24 1274
需要一个pre[  ] 和一个 next[   ] 一开始指向 -1表示没有前值 没有后值 大小确定 然后用一个val[   ]数组来存相当与一个节点里面的值 一个tot值 插入 新的 节点就+1  在中间插入新节点只要修改pre和next的值 hdu 多校2013 第十场 的 editor 运用了这一结构 并且
famousDT的专栏
09-27 125
/******************************************************************************************************  ** Copyright (C) 2011.07.01-2013.0
数据结构与算法Java版本（5）双链表改删功能测试
薛定谔的猫的博客
08-24 368
本文主要介绍了有关双链表的原理和单链表缺点分析，具体解决了双向链表的遍历、添加、修改、删除的java代码实现，最后写了有关new对象在eclipse的快捷键
C++：【数据结构】用数组实现的单链表和双向链表
最新发布
qq_73176808的博客
05-25 1351
链表是程序设计中一种十分重要的数据结构。正如它的名字一样，它是一个“链状”的数据结构。如下图所示：其中每个节点都可以保存数据，同时每个节点又有一个指针指向下一个节点，来形成链状结构。那么这时候就会有人要说了，这不就是数组吗。其实不然，它和数组各有优缺点。数组就是一串连续的存储单元，而链表不一定是连续的存储单元。数组的优点就是可以很快的访问到某个元素，因为只需要给数组名取下标，就可以访问到某个元素了；但是链表要访问一个元素，需要从头节点开始往后找，越接近链表尾的元素访问的越慢。但是链表可以。
算法导论--10.3-4 多数组表示双向链表（紧凑）
臻舍
05-31 938
问题：双向链表的所有m个元素在存储器中保持紧凑，即在多数组表示中占用前m个下标 思路：分配内存： 总是分配相邻的存储位置；     释放内存：若删除链表中的一个元素，导致存储位置中间空了一个，让数组的最后一个元素补上，并修改其prev和next值 代码： #include #include using namespace std; int n=15, f=-1, head=-1;/
Java排序动态数组和双向链表的实现教程
- **getSize()方法**: 需要在DynamicArrayInt和LinkedListInt类中实现此方法，用于返回数组或链表中元素的数量。这要求开发者能够访问并统计集合内的元素个数。 - **contains(int value)方法**: 此方法应用于检查...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值