Question

#include <stdio.h>
#include <malloc.h>
#include <conio.h>

typedef struct node
{
    int info;
    struct node* next;
} node;

node* fi = NULL, *la = NULL, *ptr;

void insertfi()
{
    ptr = (node*)malloc(sizeof(node));
    printf("\nEnter info\n");
    scanf("%d", &ptr->info);
    ptr->next = fi;
    if (fi == NULL && la == NULL)
    {
        fi = la = ptr;
    }
    else
    {
        fi = ptr;
    }
}

void print()
{
    ptr = fi;
    while (ptr != NULL)
    {
        printf("|%d|-->", ptr->info);
        ptr = ptr->next;
    }
}

int main()
{
    int i, ch;
    do
    {
        printf("\nEnter your choice \n1.insert node\n2.view node\n3.exit\n");
        scanf("%d", &ch);
        if (ch == 1)
        {
            insertfi();
        }
        else if (ch == 2)
        {
            print();
        }
        else
            printf("Exiting\n");
    } while (ch != 3);
    return 0;
}

我想在我正在处理的程序中节省空间。该程序通过在结构中的下一个指针中存储节点的地址来创建节点并加入它们。我想要一些方法不使用* next指针转到下一个节点 - 如果我这样做，我将能够节省2个字节的内存。

我一直在考虑在动态内存分配中是否存在连续分配地址的方法，这样我就会将第一个节点的地址存储在指针中，然后在修改地址后遍历或执行任何操作。< / p>

地址如何工作 - 我的意思是如何通过在指针中输入地址来访问它们然后打印出来？

以下是一个示例程序：

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

int main ()
{
    int a[10],i,*ptr;
    for(i=0;i<10;i++)
    {
        a[i]=rand()%15;
    }
    for(i=0;i<10;i++)
    {
        printf("%6x\n",&a[i]);
    }
    ptr=&a[0];
    printf("\n\n\n%d\n",*ptr);

}

它以连续的方式打印地址，但我不知道如何手动分配它们，如ptr = 0022ff04，然后使用`printf（“％d”，* ptr）;

#include<conio.h>

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<stdbool.h>

#define max 20

typedef struct node
{
    int info;
    int row;
    int colum;
    struct node *next;
}node;

node *ptr,*fi=NULL,*la=NULL;

int r,c,i,j,sparse[max][max],decompmatx[max][max];

void makenode(int getrow,int getcolum,int getinfo)

{
ptr=(node*)malloc(sizeof(node));
ptr->next=NULL;
if(fi==NULL)
{
    ptr->info=getinfo;
    ptr->row=getrow;
    ptr->colum=getcolum;
    fi=la=ptr;  
}
else
{
    la->next=ptr;
    la=ptr;
    ptr->info=getinfo;
    ptr->row=getrow;
    ptr->colum=getcolum;
}

}

void decompress()

{
int temp;
temp=0;
ptr=fi;
while(ptr!=NULL)
{
    decompmatx[ptr->row][ptr->colum]=ptr->info;
    ptr=ptr->next;
}
for(i=0;i<=r-1;i++)
    {
        for (j=0;j<=c-1;j++)
        {
            if(decompmatx[i][j]>0)
            {

            }
            else
            decompmatx[i][j]=0;
        }
    }
printf("\nValue decompressed\n");
for(i=0;i<r;i++)
{
    for(j=0;j<c;j++)
    printf("%d  ",decompmatx[i][j]);
    if((temp%c)==0)
    printf("\n");
    else
    temp++;

}

}

void showsparse()

{
int temp;
temp=0;
for(i=0;i<r;i++)
{
    for(j=0;j<c;j++)
    printf("%d  ",sparse[i][j]);
    if((temp%c)==0)
    printf("\n");
    else
    temp++;

}

}

void print()

{
ptr=fi;
while(ptr!=NULL)
{
    printf("|%d|%d||%d|--->",ptr->info,ptr->row,ptr->colum);
    ptr=ptr->next;
}   


}

int main()

{
int ch;
do
{
printf("\nInput choice\n1.Make Sparse Matrix\n2.compress Matrix\n3.Decompress 
Matrix\n4.Exit...");
scanf("%d",&ch);
if(ch==1)
{
    printf("Input the rows\n");
    scanf("%d",&r);
    printf("Enter colum\n");
    scanf("%d",&c);
    printf("Printing the %dx%d matrix\n",r,c);
    for(i=0;i<=r-1;i++)
    {
        for (j=0;j<=c-1;j++)
        {
            sparse[i][j]=rand()%2;
        }
    }
    showsparse();
    printf("\nTotal Byte comsuming is =%d\n",r*c*2);
}
else if(ch==2)
{
    for(i=0;i<=r-1;i++)
    {
        for (j=0;j<=c-1;j++)
        {
            if(sparse[i][j]!=0)
            {
                makenode(i,j,sparse[i][j]);
            }

        }
    }
    printf("Data compressed\n");
    print();
    printf("size of node =%d",sizeof(node));

}
else if(ch==3)
{
    decompress();   
}

else
{
    printf("\nExiting..............\n");
}
}while(ch!=4);

getch();


}

Answer 1

以下是jim mcnamara和japreiss在评论中提出的建议。

使用预分配对象池，而不是动态分配。例如：

node my_pool = malloc(10000 * sizeof(pool));

然后用数组索引替换指针：

typedef struct node
{
    int info;
    int next_index;
} node;

因此，使用指针，您现在可以使用数组索引。为什么这样好？

您可以确定您的对象是在连续的内存中分配的（这可以改善缓存局部性并最终提高性能）。
您可以减小对象的大小，例如使用uint16_t作为索引（如果您使用的是64位平台，甚至uint32_t也会有所改进）
如果malloc通过存储管理/调试数据而浪费内存，那么您将改进它
在数组中分配数据比使用malloc
如果您不关心何时发生重新分配，您可以一次解除所有对象的释放：free(my_pool)

当然，无条件无益。使用池有缺点（例如，它浪费了可用于其他目的的内存）。

链表中的连续动态内存分配

1 个答案: