nexta存储

Ⅰ 在下面数组A中链接储存了一个线性表，表头指针为A[0].next,试写出该线性表

A 0 1 2 3 4 5 6 7
data 60 50 78 90 34 40
next 3 5 7 2 0 4 1

A[0] ==> A[3]
==>A[2]
==>A[7]

A 0 1 2 3 4 5 6 7
data 60 50 78 90 34 40
next 3 5 7 2 0 4 1

A[0] ==> A[3] 78
==>A[2] 50
==>A[7] 40
==>A[1] 60
==>A[5] 34
==>A[4] 90
==>A[0]

是个循环链表哦
求采纳，往往帮到你了

Ⅱ p=A.first->next 这时p存储的是A链表的所有节点信息，还是只存储A的第一个节点信息

把指向下一个结点的指针赋给了P，即P存储的是一个地址，下一节点的地址。

Ⅲ 关于用指针数组存储链表节点的问题

id[1]这个代表结构体；
id[1].next ；这个是结构体指针；
相当于是a[1]=a[1].next；他们两个是不能互相赋值的。
a[1]=*a[1].next;应该是可以的，这不是把next的地址给a，要想赋给a，a[1].next=a[2].next;同类的才可以赋值。

*(id+1)=*(id+1)->next ；
这个是指针，*代表指向的内容。
*（id+1)代表a[1]，*（id+1)->next代表a[i+1].next指向的内容，等于是a[i+1]=a[i+1]next指向的结构体。

结构体的头地址是用&来取的，比如struct st{int id;
struct st *next)}a[1];
&a[0]是第一个结构体的首地址，以此类推。

Ⅳ 数据结构的小问题 p->prior->next=p->next和p->next->prior=p->prior是什么意思

假设p指的是a[i]结点的存储地址，分析语句：
第一条语句：
p->priot->next是指结点a[i-1]next指针域
p->next是指结点a[i+1]的存储地址
第一条语句的含义是将a[i-1]的next指针指向a[i+1]存储地址
第二条语句：
p->next->prior是指结点a[i+1]的prior指针域
p->priot是指结点a[i-1]的存储地址
第二条语句的含义是将a[i+1]的prior指针指向a[i-1]的存储地址
最后结果：
a[i-1]的指针域：
next指针->a[i+1]
prior指针->a[i-2]（没动）
a[i+1]的指针域：
next指针->a[i+2]（没动）
prior指针->a[i-1]
换句话说：
a[i-1]的下一个结点（直接后继）是a[i+1]，上一个结点（直接前趋）是a[i-2]；
a[i+1]的下一个结点（直接后继）是a[i+2]，上一个结点（直接前趋）是a[i-1]；
这么操作，a[i]就没了，从而实现删除a[i]结点的目的。
这就是链式存储结构通过修改存储地址的方式进行结点操作的核心方法；也是在线性表中最难学习的知识点。
我也是小白，个人结论，觉得有帮助请点个赞。

Ⅳ c语言编程 关于顺序存储与链式存储

<p></p>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct
node
{
int
data;
node
*next;
};
node
*create(int
a[],int
len)
{
int
i;
node
*head=new
node;
head->data=a[0];
node
*p=head;
node
*q;
for(i=1;i<len;i++)
{
q=new
node;
q->data=a[i];
p->next=q;
p=q;
}
p->next=NULL;
return
head;
}
node
*
insert(node
*head,int
k)
{
node
*temp=new
node;
temp->data=k;
temp->next=head;
head=temp;
return
head;
}
node
*dele(node
*head,int
m)
{
int
i;
node
*p=head;
node
*x=new
node;
node
*y=new
node;
if(m==1)
{
node
*q=head;
head=head->next;
free(q);
}
else
{
for(i=1;i<m;i++)
{
x=p;
p=p->next;
y=p->next;
}
x->next=y;
free(p);
}
return
head;
}
void
main()
{
int
a[10]={1,2,3,4,5,6,7,8,9,10};
int
len=10;
node
*head=new
node;
head=create(a,len);
node
*p=head;
printf("原数组为：");
while(p!=NULL)
{
printf("%d
",p->data);
p=p->next;
}
printf("\n输入要插入的元素：");
int
k;
scanf("%d",&k);
head=insert(head,k);
p=head;
printf("增加元素后的数组为：");
while(p!=NULL)
{
printf("%d
",p->data);
p=p->next;
}
printf("\n要删除的元素位置为：");
int
m;
scanf("%d",&m);
head=dele(head,m);
p=head;
printf("删除元素后的数组为：");
while(p!=NULL)
{
printf("%d
",p->data);
p=p->next;
}
}<p>此处为链表实现的方式，链表的好处在于内存不必连续，并且顺序存储
</p>
<p>顺序存储结构的特点是：连续的内存，随机存储。</p>

Ⅵ 采用链式存储结构存储’a’,’b’,’c’,’d’,’e’,’f’六个字

#include<stdio.h>
#include<stdlib.h>
typedef struct node
{
char ch;
struct node *next;
}node,*link;
link creatlist()
{
link head=NULL,p,r;
char str[10]={"abcdef"};
int i=0;
while(str[i]!='\0')
{
p=(link)malloc(sizeof(node));
p->ch=str[i];
if(head==NULL) {head=r=p;}
else
{
r->next=p;
r=p;
}
i++;
}
r->next=NULL;
return head;
}
void show(link head)
{
link p=head;
while(p)
{
printf("%c ",p->ch);
p=p->next;
}
printf("\n");
}
int main()
{
link head,r,p;
int i=0;
head=creatlist();
show(head);
r=head;
printf("显示第三个数据:");
for(i=0;i<2;i++)
r=r->next;
printf("%c\n",r->ch);
printf("在第二个数据插入w:\n");
p=(link)malloc(sizeof(node));
p->ch='w';
r=head->next;
p->next=r->next;
r->next=p;
show(head);
printf("删除第一个数据:\n");
r=head;
head=head->next;
free(r);
show(head);
return 0;
}

Ⅶ 【急求】用带头单链表存储结构表示两个集合A、B（集合A、B都是有序递增的情况）实现集合求并集C的运算

//无头链表
//#define data data_int
#include "head.h"
struct LNode{
// char data[10];
int data;
struct LNode *next;
};
typedef struct LNode * LinkList;

void InitList_L(LinkList &L)//链表构造函数
{
L=new LNode;
L->next=NULL;
}

void PrintList_L(LinkList &H)//链表显示函数
{
LinkList L=H;
L=L->next;
while(1)
{
cout<<"data value is "<<L->data<<endl;
L=L->next;
if (L==NULL)
return;
}
}

void Insert_L(LinkList &H,int n=0)//插入链表
{
LinkList L=H;
LinkList p=L;
int i=0;
if (n==0)
{
n=1;
while(p->next!=NULL)
{
p=p->next;
n++;
}

}
else if (n<1)
{
cout<<"error"<<endl;
return;
}
for (i=0;i<n-1;i++)
{
if (L->next==NULL)
{
cout<<"error"<<endl;
return;
}
L=L->next;
}
p=new LNode;
cout<<"please input a value:";
cin>>p->data;
p->next=L->next;
L->next=p;
}
LinkList bing_LinkList(LinkList a,LinkList b)
{
LinkList c;
LinkList nc;
LinkList t;
InitList_L(c);
nc=c;
a=a->next;
while (a!=NULL)//复制a到c
{
t=new LNode;
t->data=a->data;
nc->next=t;
t->next=NULL;
nc=nc->next;
a=a->next;
}
b=b->next;
while (b!=NULL)
{
nc=c;
while (nc->next!=NULL)
{
if (nc->next->data==b->data)
break;
nc=nc->next;
}
if (nc->next==NULL)
{
t=new LNode;
t->data=b->data;
nc->next=t;
t->next=NULL;
nc=nc->next;
}
b=b->next;
}
return c;
}
void main()
{
LinkList a,b,c;
int i=0;

InitList_L(a);
cout<<"\nI will input date."<<endl;
for (i=1;i<=3;i++)
Insert_L(a,i);
// PrintList_L(a);
InitList_L(b);
cout<<"\nI will input date."<<endl;
for (i=1;i<=3;i++)
Insert_L(b,i);
// PrintList_L(b);

c=bing_LinkList(a,b);
PrintList_L(c);

}

Ⅷ next数组是什么

1.next数组第一二位一定分别为0，1：

2.看第三位，按照next数组求解方法。第三位a的前一位是第二位的b，b的next值是1对应内容是a，b与a不同，则继续向前寻找next值对应的内容与第二位的b进行比较。但是找到第一位都没有找到与第二位的b相等的内容，所以第三位a的next值为1，则：

3.看第四位的b，b的前一位a的next值1对应内容为a，相同，所以该位b的next值就是前一位a的next（第三位的a）值加上1，即为2：

4.看第五位a，a的前一位b的next值2对应内容为b，相等，所以第五位a的next值就是其前一位b的next值加上1，即为3：

Ⅸ 关于数据结构中，画出广义表(((a),b),(d),(e,f))的存储结构

如图：

任意广义表都由表头和表尾组成，所以都能用一个表结点表示。表头可能是原子，也可能是广义表。表尾一定是广义表或空表，所以能用一个表结点表示或表明其是空表。

(9)nexta存储扩展阅读

同层存储所有兄弟的扩展链式存储

在这种存储方式中，同样设置两类结点：表结点和原子结点。与第一种方式不同的是该种存储方式中的表结点和原子结点都有一个指针指向同一层中下一个元素结点的指针。该指针类似于单向链表中的next指针，把同一层的元素结点链接到一起。