数据结构中，单链表节点初始化问题？C++中链表初始化

本文目录

• 数据结构中，单链表节点初始化问题
• C++中链表初始化
• 链表的初始化
• 循环链表的生成、初始化
• 数组初始化链表,
• 关于单链表初始化的问题
• 单链表初始化的作用
• 请进，链表初始化为什么要二级指针
• 初始化单链表h；

数据结构中，单链表节点初始化问题

不是很明白你的意思，主函数之前你分配了头结点了吗？我没看到。
这一句是动态分配一个LNode型结点，并返回LNode*型空间，即给头结点分配一个空间。你前面确实声明了一个头指针，但关键是头指针并没有指向头结点。要知道链表是依靠结点的指针域依次寻找的，所以这里必须分配一个头结点（这一步少不得）。我是这么理解的。

C++中链表初始化

p1=p2=(Cwow *)malloc(sizeof(Cwow));

问题出在这一句，这里只是负责分配一个空间大小sizeof(Cwow)的堆内存给p1.这块内存的数据是没有经过初始化的。

所以当你调用p1-》name时就会报错，因为string name的内容是随机的。

解决办法有两个：

1. 使用new操作符，  p1 = p2 = new Cwow;

2. 在p1=p2=(Cwow *)malloc(sizeof(Cwow));后面增加一句，memset(p1, 0 ,sizeof(Cwow));

建议使用第一种方法，使用new操作符，会自动调用string的默认构造函数。

链表的初始化

我们刚做了这个作业 发给你吧！！
typedef struct node{//建立单链表的顺序存储结构
int data;
struct node *next;
}*LinkList,Node;
//建立单链表
LinkList creat(int n){//正序输入n个元素的值,建立带表头结点的单链线性表
LinkList head,r,p;
int x,i;
head=(Node*)malloc(sizeof(Node)); //生成新结点
r=head;
printf("输入元素:\n");
for(i=n;i》0;i--)
{
scanf("%d",&x); //输入元素值
p=(Node*)malloc(sizeof(Node));
p-》data=x;
r-》next=p;
r=p;//插入到表头
}
r-》next=NULL;
return head;
}
//实现单链表元素插入函数
LinkList Insert(LinkList &L,int i,int e)
{//在带结点的单链线性表L中第i个位置之前插入元素e
LinkList p ,s;
p=L;
int j=0;
while(p&&j《i-1)
{
p=p-》next;
++j;
}//寻找第i-1个结点
if(!p||j》i-1)exit(0);//i小于1或者大于表长加1
s=(LinkList)malloc(sizeof(Node));//生成新结点
s-》data=e;s-》next=p-》next;
p-》next=s;//将结点s插入L中
return L;
}
//实现单链表元素删除函数
LinkList Delete(LinkList &L,int i,int &e)
{//在带结点的单链线性表L中，删除第i个元素，并由e返回其值
LinkList q,s;
q=L;
int j=0;
while(q-》next&&j《i-1)
{//寻找第i个结点，并令q指向其前趋
q=q-》next;
++j;
}
if(!(q-》next)||j》i-1)exit(0);//删除位置不合理
s=q-》next;q-》next=s-》next;
e=s-》data;free(s);//删除并释放结点
return L;
}
//显示单链表中的元素
void output(LinkList head) {
LinkList p;
p=head-》next;
do{
printf("%3d",p-》data);
p=p-》next;
}while(p);
printf("\n");
}

循环链表的生成、初始化

参考下，你可以做个函数来统一插入
#include 《stdio.h》
#include 《string.h》
#include 《stdlib.h》
typedef struct PL
{
char pl;
struct PL *next;
}PL,*PLList;
void main()
{

PLList p,q,head;//head为第一个节点,p为插入节点,q为p之前节点
p=q=head=(PLList)malloc(sizeof(PL));//建立第一个节点
strcpy(p-》pl,"111");//赋值给pl

p=(PLList)malloc(sizeof(PL));//建立第二个节点
strcpy(p-》pl,"222");//赋值给pl
q-》next=p;
q=p;
p=(PLList)malloc(sizeof(PL));//建立第三个节点
strcpy(p-》pl,"333");//赋值给pl
q-》next=p;
q=p;
p=(PLList)malloc(sizeof(PL));//建立第四个节点
strcpy(p-》pl,"444");//赋值给pl
q-》next=p;
p-》next=head;//注意这里将链表进行循环，让第四个指向第一个
//打印这些信息
p=head;
do
{

printf("%s\n",p-》pl);
p=p-》next;
}
while(p!=head);
}

数组初始化链表,

#include 《stdio.h》
#include 《stdlib.h》
typedef struct _NODE
{
int data;
struct _NODE* next;
}NODE;
int TEST_ARRAY = {1,2,3,4,5,6,7,8,9,10};
struct _NODE * __gListTest = NULL;
int ListInit(struct _NODE *list, int *pNum, int num);
int main()
{
NODE *list_ptr = NULL;
NODE *next_ptr = NULL;
int i = 0;
__gListTest = (NODE *)calloc(1,sizeof(NODE));
if(__gListTest == NULL)
{
printf("calloc error\n");
return -1;
}
if(ListInit(__gListTest, TEST_ARRAY, sizeof(TEST_ARRAY)/sizeof(int)) == -1)
{
printf("init error\n");
return -1;
}
//动态申请的内存必须手动释放
list_ptr = __gListTest;
for(i=0; i《sizeof(TEST_ARRAY)/sizeof(int); i++)
{
printf("list number %d:data:%d, next:0x%x\n",i+1,list_ptr-》data,list_ptr-》next);
next_ptr = list_ptr-》next;
list_ptr-》data = 0;
list_ptr-》next = NULL;
free(list_ptr);
list_ptr = next_ptr;
}
printf("printf any key to stop the program!");
getchar();
return 0;
}
int ListInit(struct _NODE *list, int *pNum, int num)
{
//²¹³ä
NODE *list_ptr = list;
NODE *next_ptr = NULL;
int i = 0;
for(i=0; i《num; i++)
{
next_ptr = (NODE *)calloc(1,sizeof(NODE));
if(next_ptr == NULL)
{
printf("calloc error\n");
return -1;
}
list_ptr-》data = pNum;
list_ptr-》next = next_ptr;
list_ptr=list_ptr-》next;
}
return 0;//
}

关于单链表初始化的问题

一般malloc之后的节点空间都需要释放的，释放出错那可能是你的p地址操作到了非法部分！也

就是程序的问题！ 

给个范例你看看：

#include 《stdio.h》

#include 《stdlib.h》

#define NUM 10//总共10个节点（包含头结点）

typedef struct node//结点

{

int num;//编号

int data;//数据

struct node* next;//下一个结点

}Node,*pNode;

InitList( const pNode phead )

{

pNode endNode=phead;//指向最后一个节点

pNode add = NULL;//要添加的节点

inti=1;

for ( ; i《NUM; i++ )

{

if ( NULL==(add = (pNode)malloc(sizeof(Node))) )

{

printf("memory overflow!\n");

}

printf("Please enter %dth Node data:",i);

scanf("%d",&add-》data);

add-》num = i;//编号从1--9

//新添加的节点指针域指向尾节点的下一个节点，即NULL

//等同于 add-》next = NULL;

add-》next = endNode-》next;

//原先的尾节点指针域指向新添加的节点

endNode-》next = add;

//更新尾节点，将新添加的节点作为新的尾节点

endNode = add;

}

}

void main(void)

{

pNode phead = NULL;

pNode temp = NULL;

int i=0;

//初始化头结点(第0个节点)

if ( NULL==(phead = (pNode)malloc(sizeof(Node))) )

{

printf("memory overflow!\n");

}

phead-》num = 0;//编号为0

phead-》next = NULL;//next指向空指针

//初始化其他节点

InitList( phead );

//显示最终建成的链表

temp = phead;//中间变量指针指向头结点

printf("this is the list that you create:\n");

for ( ; i《NUM; i++ )

{

printf("\t%d\t%d\n",temp-》num,temp-》data);

temp = temp-》next;

}

//从头结点开始依次free

while ( NULL != phead )

{

temp = phead-》next;

free(phead);

phead = temp;

}

}

单链表初始化的作用

链表的初始化其实就是链表的创建的过程，它的初始化其实和变量、指针的初始化一样，如果你定义了一个指针，而没有对其进行初始化，这个指针就是一个“野指针”，指向一块垃圾内存，这是很危险的，链表的初始化就是为了让程序员能够获取链表的首地址，然后对其进行插入、删除、排序等操作了！

请进，链表初始化为什么要二级指针

简单来说，修改头指针则必须传递头指针的地址，否则传递头指针值即可（即头指针本身）。这与普通变量类似，当需要修改普通变量的值，需传递其地址，否则传递普通变量的值即可（即这个变量的拷贝）。使用二级指针，很方便就修改了传入的结点一级指针的值。 如果用一级指针，则只能通过指针修改指针所指内容，却无法修改指针的值，也就是指针所指的内存块。所以创建链表和销毁链表需要二级指针或者一级指针引用。

初始化单链表h；

int InitList(List &h) //初始化一个带头结点的链表
{
h=(List)malloc(sizeof(_List)); //分配内存空间
if(!h)
return 0;
h-》next=NULL;
return 1;
}