链表如何访问
㈠ 链表的操作（链表的建立，访问，删除链表指定结点，增加结点）
/*这个是我刚才写的，那个问题结果找不到了，给你吧*/#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "conio.h"
#define N 3
#define MAX 12
#define OK 1
#define ERROR 0
#define FALSE 0
#define TRUE 1
#define OVERFLOW -2
#define FILE_PATH_NAME "c:\\student"
typedef int Status;
FILE *fp;
typedef struct stu
{
char num[MAX];
char name[MAX];
int score[N];
int total;
int average;
}ElemType;
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
LinkList L;//保存成绩的链表
int count=0;//所有人数
int TAB=FALSE;
Status ListInit(LinkList *L)
{
*L=(LinkList)malloc(sizeof(LNode));
if(!*L)exit(OVERFLOW);
(*L)->next=NULL;
return OK;
}
Status InsertByTotal(LinkList L,ElemType e)
{
LinkList p,q;
p=L;q=L->next;
while(q&&q->data.total<e.total)
{
p=q;
q=q->next;
}
p->next=(LinkList)malloc(sizeof(LNode));
p->next->data=e;
p->next->next=q;
return OK;
}
void ListTraverse(LinkList L,void(*vi)(ElemType))
{
LinkList p=L->next;
while(p)
{
vi(p->data);
p=p->next;
}
}
Status FindNum(LinkList L,char num[],LinkList *p,LinkList *q)
{
*p=L;
*q=L->next;
while(*q)
{
if(!strcmp((*q)->data.num,num))
return OK;
*p=*q;
*q=(*q)->next;
}
return FALSE;
}
Status ReadFromFile(ElemType *e)
{
int i;
i=fread(e,sizeof(ElemType),1,fp);
if(i==1)return OK;
return ERROR;
}
void WriteToFile(ElemType e)
{
fwrite(&e,sizeof(ElemType),1,fp);
}
void BuildFile()
{
char key;
if((fp=fopen(FILE_PATH_NAME,"r"))==NULL)
{
printf("文件打开失败!\n是否建立新文件?Y/N ");
key=getchar();
if(key=='Y'||key=='y')
{
fp=fopen(FILE_PATH_NAME,"w");
if(fp)
{
printf("文件成功建立！\n");
fclose(fp);
printf("请按任意键继续...");
fflush(stdin);
getch();
system("cls");
}
}
else
{
printf("感谢使用!\n");
exit(0);
}
}
}
void cls()
{
printf("请按任意键继续...");
fflush(stdin);
getch();
system("cls");
}
void Menu()
{
printf("\t\t\t**********************\n");
printf("\t\t\t*----学生成绩管理----*\n");
printf("\t\t\t**********************\n");
}
void ReadIn(LinkList L)
{
int i,n;
ElemType e;
LinkList p,q;
system("cls");
Menu();
printf("本次录入学生人数:");
scanf("%d",&n);
if(n==0)
{
cls();
return;
}
for(i=1;i<=n;++i,++count)
{
printf("请输入第%d位学生信息:\n",i);
printf("学号:");
scanf("%s",e.num);
if(FindNum(L,e.num,&p,&q))
{
printf("该学号已经存在,请确认重新输入\n");
--i;
cls();
Menu();
continue;
}
printf("姓名:");
scanf("%s",e.name);
printf("语文成绩:");
scanf("%d",&e.score[0]);
printf("数学成绩:");
scanf("%d",&e.score[1]);
printf("英语成绩:");
scanf("%d",&e.score[2]);
e.total=e.score[0]+e.score[1]+e.score[2];
e.average=e.total/N;
InsertByTotal(L,e);
if(i==n)
{
printf("所有成绩录入完成\n");
cls();
}
else
{ printf("第%d位学生成绩成功录入\n");
cls();
Menu();
}
}
}
void ShowAll(LinkList L)
{
LinkList p=L->next;
system("cls");
Menu();
while(p)
{
if(TAB==FALSE)
{
system("cls");
printf("------------------------所有学生成绩名单---------------------------------\n");
printf("学号 姓名 数学 语文 英语 平均 总分\n");
TAB=TRUE;
}
printf("%-10s%-10s%-10d%-10d%-10d%-10d%-10d\n",p->data.num,p->data.name,p->data.score[0],p->data.score[1],\
p->data.score[2],p->data.average,p->data.total);
p=p->next;
}
printf("\n\n说明:成绩按照由高到低的顺序排列\n");
TAB=FALSE;
cls();
}
void SearchNum(LinkList L)
{
char num[MAX];
LinkList p,q;
system("cls");
Menu();
printf("输入学号:");
scanf("%s",num);
if(!FindNum(L,num,&p,&q))
printf("没有学号位%s的学生",num);
else
{
printf("学号位%s的学生信息如下\n",num);
printf("学号 姓名 数学 语文 英语 平均 总分\n");
printf("%-10s%-10s%-10d%-10d%-10d%-10d%-10d\n",q->data.num,q->data.name,q->data.score[0],q->data.score[1],\
q->data.score[2],q->data.average,q->data.total);
}
cls();
}
void SearchName(LinkList L)
{
char name[MAX];
int FIRST=FALSE;
LinkList p=L->next;
system("cls");
Menu();
printf("输入姓名:");
scanf("%s",name);
while(p)
{
if(!strcmp(p->data.name,name))
{
if(FIRST==FALSE)
{
printf("所有姓名为%s的学生信息如下:\n");
printf("学号 姓名 数学 语文 英语 平均 总分\n");
FIRST=TRUE;
}
printf("%-10s%-10s%-10d%-10d%-10d%-10d%-10d\n",p->data.num,p->data.name,p->data.score[0],p->data.score[1],\
p->data.score[2],p->data.average,p->data.total);
}
p=p->next;
}
if(FIRST==FALSE)
printf("没有姓名为%s的学生",name);
cls();
}
void SaveData()
{
fp=fopen(FILE_PATH_NAME,"wb");
if(!fp)
{
printf("保存失败\n");
return;
}
else
{
ListTraverse(L,WriteToFile);
fclose(fp);
printf("保存完成\n");
cls();
}
}
int main()
{
int EXIT=FALSE;
int i,SUM;
ElemType e;
BuildFile();
ListInit(&L);
SUM=0;
fp=fopen(FILE_PATH_NAME,"rb");
if(!fp)
{
printf("数据读取失败");
cls();
}
else
{
while(ReadFromFile(&e))
{
InsertByTotal(L,e);
SUM++;
}
fclose(fp);
if(SUM>0)
printf("%d条数据成功读取\n",SUM);
else
printf("无任何数据可以读入\n");
cls();
}
while(EXIT==FALSE)
{
Menu();
fflush(stdin);
printf("(1):录入成绩\n");
printf("(2):学号查询\n");
printf("(3):姓名查询\n");
printf("(4):显示成绩\n");
printf("(5):保存成绩\n");
printf("(6):退出系统\n");
printf("请选择功能:");
scanf("%d",&i);
switch(i)
{
case 1:ReadIn(L);
break;
case 2:SearchNum(L);
break;
case 3:SearchName(L);
break;
case 4:ShowAll(L);
break;
case 5:SaveData();
break;
case 6:EXIT=TRUE;
printf("谢谢使用!\n");
break;
default:printf("非法输入，请输入1-6\n");
cls();
break;
}
}
}
㈡ c语言链表的建立和顺序访问各节点的数据域
#include<stdio.h>
#include<stdlib.h>
typedefstructstudent
{
intscore;
structstudent*next;
}student;
student*creatlist()
{
inti=0;
student*head,*p,*q;
head=(student*)malloc(sizeof(student));
p=head;
scanf("%d",&i);
while(i!=-1)
{
q=(student*)malloc(sizeof(student));
q->score=i;
p->next=q;
p=q;
scanf("%d",&i);
}
p->next=NULL;
returnhead;
}
voidprint(student*head)
{
if(!head)return;
student*p=head->next;
while(p)
{
printf("%d",p->score);
p=p->next;
}
}
intmain()
{
student*head;
head=creatlist();
print(head);
system("pause");
return0;
}
㈢ iOS - 链表
链表最基本的结构是在每个节点保存数据到下一个节点的地址，在最后一个节点保存一个特殊的结束标记。另外在一个固定的位置保存指向第一个节点的指针，有的时候也会同时储存指向最后一个节点的指针。但是也可以提前把一个节点的位置另外保存起来，然后直接访问，当然如果只是访问数据就没必要了，不如在链表上出错指向实际数据的指针。这样一般是为了访问链表中下一个或者前一个节点
优势 :
可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理
链表最明显的好处是，常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序，数组的存取往往要在不同的排列顺序中转换。而列表是一种自我指示数据类型，因为它包含指向另一个相同类型的数据的指针（链接）,同时，链表允许插入和移除表上任意位置上的节点.
劣势 ：
链表由于增加了节点的指针域，空间开销比较大；另外，链表失去了数组随机读取的优点，一般查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置
链表中最简单的一种是单向链表
一个单向链表的节点被分成两个部分，它包含两个域，一个信息域和一个指针域，第一个部分保存或者显示关于节点的信息，第二个节点存储下一个节点的地址，而最后一个节点则指向一个空值。单向链表只可向一个方向遍历
单链表有一个头节点 head ,指向链表在内存的首地址，链表中的每一个节点的数据类型为结构体类型，节点有两个成员：整型成员（实际需要保存的数据）和指向下一个结构体类型节点的指针即下一个节点的地址（事实上，此单链表是用于存放整型数据的动态数组）。链表按此结构对各节点的访问需从链表的头找起，后续节点的地址由当前节点给出。无论在表中访问哪一个节点，都需要从链表的头开始，顺序向后查找。链表的尾节点由于无后续节点，其指针域为空，写作为NULL
上图还给出这样一层含义，链表中的各节点在内存的存储地址不是连续的，其各节点的地址是在需要时向系统申请分配的，系统根据内存当前的情况，即可以连续的分配地址，也可以跳跃式分配地址
单向列表程序的实现
在链表节点的定义中，除一个整形的成员外，成员 next 是指向与节点类型完全相同的指针
在链表节点的数据结构中，非常特殊的一点就是结构体内的指针域的数据类型使用了未定义成功的数据类型。 这是C中唯一规定可以先使用后定义的数据结构
创建一个存放正整数单链表，输入0或小于0的数，结束创建链表，并打印链表中的
在链表的创建过程中，链表的头指针是非常重要的参数，因为对链表的输出和查找都要从链表的头开始，所以链表创建成功后，要返回一个链表节点的地址，即头指针
程序执行流程:
双向链表其实是单向链表的改进，当我们对单链表进行操作时，有时你要对某个节点的直接前驱进行操作时，又必须从表头开始查找。这是由单链表节点的结构所限制的，因为单链表每个节点只有一个存储直接后继节点地址的链域，那么能不能定义一个既有存储直接后继节点地址的链域，又有存储直接前驱节点地址的链域的这样一个双链节点结构呢？ 这就是双向链表
在双向链表中，节点除含有数据域外，还有两个链域，一个存储直接后继节点地址，一般称为右链域（当此"连接"为最后一个"连接"时，指向空值或空列表）；一个存储直接前驱节点地址，称为左链域（当此"连接"为第一个"连接"时，指向空值或空列表）
双向链表节点定义
当然，也可以把一个双向链表构成一个双向循环链表。
双向列表与单向链表一样，也有三种基本运算：查找、插入和删除
循环链表是与单向链表一样，是一种链式的存储结构，所不同的是，循环链表的最后一个节点的指针是指向该循环链表的第一个节点或者头节点，从而构成一个环形的链
循环链表的运算与单链表的运算基本一致，所不同的有以下几点：
块状链表本身是一个链表，但是链表存储的不是一般的数据，而是由这些数据组成的顺序表。每一个块状链表的节点，也就是顺序表，可以被叫做一个块
块状链表另一个特点是相对于普通链表来说节省内存，因为不用保存指向每一个数据节点的指针
参考: ios -链表的简单认识
㈣ 怎么访问单链表的节点，希望大家给我回复喔
while(head != null){
if(head->data == XX){
return head;
}
head = head -> next;
}
return null;
㈤ 怎样访问链表中的各结点
指针指向第一个节点(p=head->next) 读出它的数据(p->data) 然后指向下一个节点(p=p->next;)
重复上面步骤 循环条件p不空(p!=NULL)
㈥ C++类为链表结点怎么访问数据成员
法1：使用友元（友元类或者友元函数）
法2：在people类中定义一个方法，用来比较两个people对象的age大小。
法3：在people类中提供一个公共方法访问的age成员的值。
法4：直接公开people类的age成员。
法5：还没想到……
㈦ Java中如何访问链表中的数组
数组就像身上编了号站成一排的人，要找第10个人很容易，根据人身上的编号很快就能找到。但插入、删除慢，要望某个位置插入或删除一个人时，后面的人身上的编号都要变。当然，加入或删除的人始终末尾的也快。
链表就像手牵着手站成一圈的人，要找第10个人不容易，必须从第一个人一个个数过去。但插入、删除快。插入时只要解开两个人的手，并重新牵上新加进来的人的手就可以。删除一样的道理。
Java中，ArrayList、LinkedList就是分别用数组和链表做内部实现的。
没有谁好谁坏，根据不同情况下，用适合自己的。
㈧ c++链表的创建和访问
语法上的错误，
main修改成：
int main(){
student *head;//定义student类型的指针head，也就是链表头指针
head=createList();//调用createList函数录入学生信息
printList(head);//调用printList输出学生信息
}
㈨ 单双向链表原理
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。
1链表操作编辑
双向链表
双向链表
线性表的双向链表存储结构：
带头结点的双向循环链表的基本操作：
销毁双向循环链表L：
重置链表为空表：
验证是否为空表：
2元素操作编辑
计算表内元素个数
赋值：
查找元素：
查找元素前驱：
查找元素后继：
查找元素地址：
元素的插入：
元素的删除：
正序查找：
逆序查找：
3循环链表编辑
循环链表是一种链式存储结构，它的最后一个结点指向头结点，形成一个环。因此，从循环链表中的任何一个结点出发都能找到任何其他结点。循环链表的操作和单链表的操作基本一致，差别仅仅在于算法中的循环条件有所不同。
㈩ 如何在子进程中访问父进程创建的链表
子进程要访问的话，把链表设置成公共可见的试试。比较好的方式应该是把链表设置成入参，传给子进程，子进程修改后返回