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指針，把同一層的元素結點鏈接到一起。