楼主这两天有点松懈了，没那么大激情了，不过还是会继续坚持的，我得好好反思下

楼主昨天有事情，没有及时发帖，今天不上（开学的第十一个晚上）  不过也没学多少
//二维数组中 请务必记住a[i]和*(a+i)是等价的  a[i]+j就是a[i][j]的值
//所以*(*(a+i)+j)是与a[i][j]等价的   //i是行数  j是列数 *符号才是对指针变量指向地址的值进行读写操作
/*int main()
{
    int a[3][4]={{1,3,5,7},{9,11,13,15},{17,19,21,23}};
    printf("%d,%d\n",a,*a);//a就是a[0],a[0]就是一个地址，就是将a[0]的地址以十进制的形式打印   *a就是使指针变量指向数组a[0]的地址，等价于a[0](数组a[0]就是一个地址)
    printf("%d,%d\n",a[0],*(a+0));//0行0列元素的地址
    printf("%d,%d\n",&a[0],&a[0][0]);
    printf("%d,%d\n",a[1],a+1);//a+1等价a[1]，因为数组就是一个地址，所以不加*号打印出来也是地址的十进制形式
    printf("%d,%d\n",&a[1][0],*(a+1)+0);//一行一列元素的地址
    printf("%d,%d\n",a[2],*(a+2));//2行0列元素地址
    return 0;
}*/
/*
%4d是printf的格式化参数，表示输出一个整型数值，输出宽度为4，且右对齐，如：
printf( "%4d", 1 );
1     //输出1的前边有3个空格，补齐4位的宽度
printf( "%4d", 11);
  11    //输出11前边有2个空格，补齐4位的宽度
printf( "%4d", 11111 );
11111  //因为超过了4位，所以前边没有空格
如果要左对齐，则改为 %-4d
*//*
int main()
{//a[1][0]地址值比a[0][1]大
    int a[3][4]={{1,3,5,7},{9,11,13,15},{17,19,21,23}};
    int*p;     //a[0]+12就是a[0][12]
    //p++每次增加四个字节，比如从a[0][0]到a[0][1]
    //二维数组也是地址上市连续的，第一行最后一个元素是与第二个首个元素地址是相连的p+1就是指向下一个yuansu
    for(p=a[0];p<a[0]+12;p++)//把a[0][0]的值赋值给指针变量p
    {                      //使p依次指向下一个元素
        if((p-a[0])%4==0) printf("\n");//p移动四次后换行
        printf("%4d",*p);
    }
    printf("\n");
    return 0;
}*//*
int main()
{
    int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};
    int (*p)[4],i,j;//指针变量p指向包含四个整形元素的一维数组  (*p)[0] (*p)[1] (*p)[2] (*p)[3]
    p=a;//p指向二维数组的零行
    printf("please enter row and colum:");//row 行  colum 圆柱上 列
    scanf("%d %d",&i,&j);
    printf("a[%d,%d]=%d\n",i,j,*(*(p+i)+j));//*(p+i)等价于a[i][0]
    return 0;
}*//*
int main()
{
    int a[4]={1,3,5,7};// subscript requires array or pointer type  下标需要数组或指针类型(一般是数组忘记打分号)
    int (*p)[4];
    p=&a;//p指向一维数组
    printf("%d\n",(*p)[2]);
    return 0;
}*//*
void average(float*p,int n)//*score指向*p   n=12  *score就是score[0][0]
{
    float*p_end;
    float sum=0,aver;
    p_end=p+n-1;//最后一个元素p+11
    for(;p<=p_end;p++)
        sum=sum+(*p);//第一次*p就是scor[0][0]的值
    aver=sum/n;
    printf("average=%5.2f\n",aver);
}
void search(float(*p)[4],int n)//实参score的值(代表该数组0行的起始地址)传给p，是p指向score[0]
{int i;//float(*p)[4]就是一个指向包含4个元素到底一维数组指针变量
    printf("The score of No.%d are:\n",n);//No就是  numero数目，号码
    for(i=0;i<4;i++)
        printf("%5.2f",*(*(p+n)+i));
    printf("\n");
}
int main()
{
    float score[3][4]={65,67,70,60,80,87,90,81,90,99,100,98};
    average(*score,12);//score得分
    search(score,2);//search 搜索
    return 0;
}*/
//%5.2f是表示五位有效数字且小数点后有两位数字的浮点型数据
/*void  search(float(*p)[4],int n)//形参p是指向包含4个float型元素的一维数组到底指针变量  n为3
{
    int i,j,flag;//flag 标示 变弱
    for(j=0;j<n;j++)//
    {flag=0;
        for(i=0;i<4;i++)//*(p+j)就是score[j]
            if(*(*(p+j)+i)<60) flag=1;//score[j][i]值<60
            if(flag==1)
            {
                printf("No.%d fails,his scores are:\n",j+1);
                for(i=0;i<4;i++)
                    printf("%5.1f",*(*(p+j)+i));//score[i][j]
                printf("\n");
            }
    }
}
int main()
{
    float score[3][4]={{65,57,70,60},{58,87,90,81},{90,99,98,100}};
    search(score,3);
    return 0;
}*/
// C语言中的数据类型没有字符串型，但是它提供了进行整串输入和输出的格式说明符%s.
//%c是按字符格式输入和输出（单个）      %s是按字符串格式输入和输出 （多个）
/*int main()
{
    char string[]="I love china!";
    printf("%s\n",string);//用%s格式声明输出string 可以输出整个字符串
    printf("%c\n",string[7]);//用%c格式输出一个字符数组的元素
    return 0;
}*//*
//C语言中只有字符变量，没有字符串变量

int main()
{char*string="I Love China!";//定义一个字符指针变量并赋值初始化
printf("%s\n",string);
    return 0;
}*/
//字符常量占一个字节的内存空间。
//字符串常量占的内存字节数等于字符串中字节数加1。增加的一个字节中存放字符"\0" (ASCII码为0)。这是字符串结束的标志。
/*int main()
{
    char a[]="I am a student.",b[20];
    int i;
    for(i=0;*(a+i)!='\0';i++)//检测字符串是不是处理完
        *(b+i)=*(a+i);//*(b+i)等价于b[i],即对b[i]地址上数据进行操作
    *(b+i)='\0';
    printf("string a is:%s\n",a);
    printf("string b is:");
    for(i=0;b[i]!='\0';i++)
        printf("%c",b[i]);
    printf("\n");
    return 0;
}*//*
int main()
{
    char a[]="I am boy.",b[20],*p1,*p2;
    p1=a;p2=b;//p1,p2分别指向a数组和b数组中的第一个元素
    for(;*p1!='\0';p1++,p2++)//p1，p2每次加一
        *p2=*p1;//将p1所指向的元素的值赋值给p2所指向的元素
    *p2='\0';//加结束符
    printf("string a is:%s\n",a);
    printf("string b is:%s\n",b);
    return 0;
}*//*
void copy_string(char from[],char to[])//数组a，b首元素的值
{int i=0;
    while(from[i]!='\0')
    {to[i]=from[i]; i++;}//把b数组的值对应复制给a数组
    to[i]='0';
}
int main()// unexpected end of file found 文件未结束
{
    char a[]="I am a teacher.";  
    char b[]="You are astudent";
    printf("string a=%s\n string b=%s\n",a,b);
    printf("copy string a to string b:\n");
    copy_string(a,b);
    printf("\n string a=%s\n string b=%s\n",a,b);
    return 0;
}*//*
int main()
{
    char a[]="I am a teacher.";
    char b[]="You are astudent";
    char*from=a,*to=b;
    printf("string a=%s\n string b=%s\n",a,b);
    printf("\ncopy string a to string b:\n");
    copy_string(from,to);
    printf("stirng a=%s\nstirng b=%s\n",a,b);
    return 0;
}*//*
void copy_string(char*from,char*to)//a，p
{
    for(;*from!='\0';from++,to++)//指针a,p依次加以
    {*to=*from;}//把指针p指向数组的值赋值给指针a指向所在数组地址上
    *to='\0';//加结束符
}
int main()
{
    char*a="I am a teachaer";
    char b[]="you are student.";
    char*p=b;
    printf("string a=%s\nstring b=%s\n",a,b);
    printf("\ncopy string a to string b:\n");
    copy_string(a,p);
    printf("string a=%s\n string b=%s\n",a,b);
    return 0;
}*///一个汉字占两个字符
//字符数组由若干个元素组成，每个元素放一个字符，而字符指针变量中存放的是地址（字符串第一个字符的地址），
//可以字符指针变量赋值，但不能对数组名赋值
//编译时为字符数组分配若干储存单元，以存放各元素的值，而对字符指针变量，只分配一个储存单元
//指针变量是可以改变的，但数组名代表一个固定的值（数组首元素的地址），不能改变
//字符数组中个元素的值是可以改变的（可以对他们再赋值），但字符指针变量指向的字符串常量中内容是不可以被取代的
//用指针变量指向一个格式字符串，可以用它代替printf函数格式字符串
/*如 char*format;//格式
     format="a=%d,b=%f\n";
     printf(format,a,b);
因此只有改变指针变量format所指向的字符串，就可以改变输入输出格式，这种printf函数称为可变格式输出函数*/
希望楼主能继续下去

开学的第十二个晚上，3月21号
谭浩强的书快完结了，加油啊，楼主，到链表了come on!!!!!
//在编译时u，编译系统为函数代码分配一段储存空间，这段储存空间的起始地址（入口地址）称为这个函数的指针
/*运行出错******************************************************************
int main()
{int max(int ,int );
    int a,b,c;
    printf("please enter a and b:");
    scanf("%d,%d",&a,&b);//出错原因 ，scanf输入时应以英文逗号间隔 ，习惯与空格间隔导致出错
    c=max(a,b);
    printf("a=%d\n b=%d\n max=%d\n",a,b,c);
    return 0;
}*//*
int max(int x,int y)
{int z;
if(x>y) z=x;
else z=y;
return (z);
}
int main()
{//主题*p两侧的括号可以省略
    int(*p)(int,int);//定义指向函数的指针·变量p
    int a,b,c;//函数名代表函数的入口地址
    p=max;//使指向函数的指针的变量p指向max函数·（该函数的起始地址）
    printf("please enter a and b:");//p=max作用就是将汗水max的入口地址赋给指针变量
    scanf("%d,%d",&a,&b);
    c=(*p)(a,b);//通过指针变量调用max函数
    printf("a=%d\nb=%d\nmax=%d\n",a,b,c);
    return 0;
}*//*
void fun(int x,int y,int(*p)(int,int))//声明形参p是指向函数的指针
{
    int result;//结果
    result=(*p)(x,y);//

    printf("%d\n",result);//打印返回值
}
int max(int x,int y)//undeclared identifier 未定义标识符
{int z;            
    if(x>y)z=x;
    else z=y;
    printf("max=");
    return (z);//将返回值返回给result
}
int min(int x,int y)
{int z;
    if(x<y)z=x;
    else z=y;
    printf("min=");
    return (z);
}
int add(int x,int y)
{int z;
    z=x+y;
    printf("sum=");
    return(z);
}
int main()
{
    int a=34,b=-21,n;
    printf("please choose 1,2or3:");
    scanf("%d",&n);
    if(n==1) fun(a,b,max);//此时fun函数的形参p指向max函数
    else if(n==2)fun(a,b,min);
    else if(n==3)fun(a,b,add);
    return 0;
}*/


/*float *search(float(*pointer)[4],int n)//形参pointer是指向一维数组的指针变量
{float*pt;
    pt=*(pointer+n);//pt的值是&score[k][0]
    return(pt);        //*(p+2)+0表示a[2]+0 也就是a[2][0]元素的地址*(*(p+2)+0)就是a[2][0]的值
}
int main()
{float score[][4]={{60,70,80,90},{56,89,67,88},{34,78,90,66}};
    float*p;
    int i,k;
    printf("enter the number of student:");
    scanf("%d",&k);
    printf("The score of No.%d are:\n",k);//score得分 No numero数目，号码
    p=search(score,k);
    for(i=0;i<4;i++)//打印数组的一行
        printf("%5.2f\t",*(p+i));//,\t 就相当于你在编程的时候按一下“Table”键，使光标以8个字符为基准进行跳跃 。
    printf("\n");
    return 0;
}*//*
float *search(float(*pointer)[4])//定义形参pointer是指向一维数组的指针变量
{int i=0;//
    float *pt;
    pt=NULL;//先使pt值为空
    for(;i<4;i++)
    if(*(*pointer+i)<60) pt=*pointer;//score[0][i]检测不及格 使pointer指向a[i][0]
    return(pt);
}
int main()
{float score[][4]={60,70,80,90,56,89,67,88,34,78,90,66};
    float*p;
    int i,j;
    for(i=0;i<3;i++)//*(score+i)就是i行o列的地址
    {p=search(score+i);//调用search函数，如果有不及格返回score[i][0]的地址,否则返回NULL（空）
        if(p==*(score+i))//pt=*pointer;
        {printf("No.%d score:",i);
            for(j=0;j<4;j++)
                printf("%5.2f ",*(p+j));//输出score[i][0]~score[i][3]
            printf("\n");
        }
    }return 0;
}*/
//若一个数组，其元素均为指针类型的数据，称为指针数组
//int*p[4]代表指针数组
//int(*p)[4]代表指向一维数组的指针变量
/*字符串比较大小的规则
  以字符是ASCII值确定，比较规则是，从第一个字符开始，顺次向后直到出现不同的字符为止
  然后以第一个不同的字符的ASCII值确定，
*//*strcmp编辑
C/C++函数，比较两个字符串。
设这两个字符串为str1，str2，
若str1==str2，则返回零；
若str1>str2，则返回正数；
若str1<str2，则返回负数
*//*
#include<string.h>//字符串处理图文件
void sort(char*name[],int n)//n=5
{char*temp;
    int i,j,k;
    for(i=0;i<n-1;i++)//i<4
    {k=i;
        for(j=i+1;j<n;j++)
            if(strcmp(name[k],name[j])>0) k=j;
        if(k!=i)
        {temp=name[i];name[i]=name[k];name[k]=temp;}
    }
}
void print(char*name[],int n)
{int i;
    for(i=0;i<n;i++)//按指针数组元素的顺序输出他们所指向的字符串
        printf("%s\n",name[i]);
}
int main()
{
    char*name[]={"Fllow me","BASIC","Great wall","FORTRAN","Computer design"};
    int n=5;  //定义指针数组，他的元素分别指向五个字符串·
    sort(name,n);
    print(name,n);
        return 0;
}*/
// *运算符的结合性是从右向左   指向指针数据的指针变量，简称为指向指针的指针
//char**p相当于char*(*p) (*p)表示指针变量  char*表示p指向char*的数据
/*int main()
{char*name[]={"Fllow me","BASIC","Great wall","FORTRAN","Computer design"};//定义指针数组，他的元素分别指向五个字符串·
 char**p;//p是指向char*型数据的指针变量
 int i;
 for(i=0;i<5;i++)
 {p=name+i;//第一次执行p指向name[0]
    printf("%s\n",*p);
 }
    return 0;
}*//*
int main()
{int a[5]={1,3,5,7,9};
int*num[5]={&a[0],&a[1],&a[2],&a[3],&a[4]};
    int**p,i;//p是指向指针型数据的指针变量
    p=num;
    for(i=0;i<5;i++)
    {printf("%d ",**p);
        p++;
    }
    printf("\n");
    return 0;
}*/
//指针就是地址，指针变量是用来存放地址的变量
//vc中memory中出现CD的都是被占用申请的空间
/*全局变量和全局静态变量的区别
   a）若程序由一个源文件构成时，无区别
   b)全局静态变量对组成该程序的其他源文件是无效的
   c)具有外部链接的静态：可以在所有的源文件里调用，除了本文件，其他文件可以通过extern的方式引用*/
//在全局变量前面加一个static，则该变量只在这个源文件中可用，称为全局静态变量
//malloc其作用是在内存的动态储存区中分配一个长度为size的连续空间，形参size为无符号整形（非负）
//calloc其作用是在内存的动态储存区中分配n个长度为size的连续空间
//free其作用是释放指针变量p所指向的动态空间
//realloc，如果已经通过malloc和calloc函数获得了动态空间，改变其大小。用realloc函数重新分配/
//void型指针吧指向任何数据
//当吧void指针赋值给不同基类型指针变量是，编译系统会自行转换，不必用户强制转换
/*#include<stdlib.h>
void check(int*p)
{int i;
    printf("They are fail:");
    for(i=0;i<5;i++)
        if(p[i]<60) printf("%d ",p[i]);
        printf("\n");
}
int main()
{int*p1,i;
    p1=(int*)malloc(5*sizeof(int));//开辟动态内存区，将地址转换为int*型，然后放在p1中
    for(i=0;i<5;i++)
        scanf("%d",p1+i);
    check(p1);
    return 0;
}*//*
struct Student
{long int num;
    char name[20];
    char sex;
    char addr[20];
}a={10101,"LiLin",'M',"123NiMaRoad"};//定义结构体变量并初始化
int main()
//%ld 输出的字节要长点  %d 的要短点。比如，一个数大于32767 用%d 就要溢出。
//%c格式对应的是单个字符，%s格式对应的是字符串
{printf("No.:%ld\nname:%s\nsex:%c\naddres:%s\n",a.num,a.name,a.sex,a.addr);
return 0;
}*//*
struct Student
{int num;
char name[20];
float score;
}student1,student2;//定义两个结构体变量student1,student2
int main()
{
    scanf("%d%s%f",&student1.num,student1.name,&student1.score);
    scanf("%d%s%f",&student2.num,student2.name,&student2.score);
    printf("The higher score is:\n");
    if(student1.score>student2.score)
        printf("%d %s %6.2f\n",student1.num,student1.name,student1.score);
    else if(student1.score>student2.score)
        printf("%d %s %6.2f\n",student2.num,student2.name,student2.score);
    else
    {    printf("%d %s %6.2f\n",student1.num,student1.name,student1.score);
            printf("%d %s %6.2f\n",student2.num,student2.name,student2.score);
    }
    return 0;
}*/
/**********************************************************************************
#include<string.h>
struct Person
{char name[20];
int count;
}leader[3]={"Li",0,"zhang",0,"Sun",0};//定义结构体数组并初始化
int main()                           //Li赋给leader[0].name   0赋给leader[0].count
{int i,j;                           //Zhang赋给leader[1].name    0赋给leader[1].count
    char leader_name[20];          //Sun赋给leader[2].name     0赋给leader[2].count
    for(i=1;i<=10;i++)
    {scanf("%s",leader_name);//吧候选人名字输入数组中
        for(j=0;j<3;j++)
            if(strcmp(leader_name,leader[j].name)==0)   leader[j].count++;
    }           //每一次循环，(共循环三次)leader_name[]数组里面的所有名字(元素)与结构体数组leader[].name比较，相同count数值加一
    printf("\nResult:\n");
    for(i=0;i<3;i++)
        printf("%5s:%d\n",leader[i].name,leader[i].count);
    return 0;
}*********************************************************************************//*
struct Student
{int num;
char name[20];
float score;
};
int main()
{struct Student stu[5]={{10101,"zhang",78},{10103,"wang",98.5},{10106,"Li",86},{10108,"Ling",73.5},{10110,"Sun",100}};//定义结构体数组并初始化
     //{10101,"zhang",78}分别赋值给stu[0].num name[20] score  其他同理
    struct Student temp;  //  定义结构体变量temp，用作交换时的临时变量
    //常变量就是用const定义的变量，常变量的值是不能被改写的，只能使用不能改写
    const int n=5;//定义常变量n
    int i,j,k;
    printf("The order is:\n");
     ///////////////////////////下面方法为选择排序法///////////////////
    for(i=0;i<n-1;i++)//i<4
    {k=i;
        for(j=i+1;j<n;j++)
            if(stu[j].score>stu[k].score)
                k=j;
            temp=stu[k];stu[k]=stu[i];stu[i]=temp;//stu[k]和stu[j]元素互换
    }////////////////////////////////////////////////////////////////
    for(i=0;i<n;i++)
        printf("%6d %8s %6.2f\n",stu[i].num,stu[i].name,stu[i].score);
    printf("\n");
    return 0;
}*//******************************
例如:定义一个字符串char a[20],和一个字符串c[]="i am a teacher!";
把c复制到a中就可以这样用:strcpy(a,c);
这个函数包含在头文件 <string.h>中
.程序代码:#include<string.h>
#include<iostream.h>
void main()
{
char a[20],c[]="i am teacher!";
strcpy(a,c);
cout<<a<<endl;
}
***********************//*
#include<string.h>
struct Student
{long num;
char name[20];
char sex;
float score;
};
int main()
{
struct Student stu_1;//定义struct Student类型的变量stu_1
struct Student*p;//定义指向struct Student类型数据的指针变量p
p=&stu_1;//p指向stu_1
stu_1.num=10101;//对结构体变量的成员赋值
// strcpy  把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间
strcpy(stu_1.name,"LiLin");
stu_1.sex='M';
stu_1.score=89.5;
printf("N0.:%ld\nname:%s\nsex:%c\nscore:%5.1f\n",stu_1.num,stu_1.name,stu_1.sex,stu_1.score);
printf("\nN0.:%ld\nname:%s\nsex:%c\nscore:%5.1f\n",(*p).num,(*p).name,(*p).sex,(*p).score);
return 0;
}*/
//c语言中允许把(*p).num用p->num代替
//“->”代表一个箭头，被称为指向运算符
/*******************************
如果p指向一个结构体变量stu，以下3中用法等价
a）stu.成员名
b）(*p).成员名
c）p->成员名
*//*
struct Student
{int num;
char name[20];
char sex;
int age;
};
struct Student stu[3]={{10101,"LiLin",'M',18},{10102,"ZhangFang",'M',19},{10103,"WangMin",'F',20}};
int main()
{
    struct Student*p;//定义指向该结构体的指针变量
    printf("No.Name        sex age\n");
    for(p=stu;p<stu+3;p++)
        printf("%5d %-20s %2c %4d\n",
                 p->num,p->name,p->sex,p->age);
    return 0;
}*//*
#define N 3
struct Student
{int num;
char name[20];
float score[3];
float aver;
};
void input(struct Student stu[])
{int i;
    printf("请输入各学生的信息：学号，姓名，三门课成绩:\n");
    for(i=0;i<N;i++)
    {
        scanf("%d %s %f %f %f %f",&stu[i].num,&stu[i].name,&stu[i].score[0],&stu[i].score[1],&stu[i].score[2]);
        stu[i].aver=(stu[i].score[0]+stu[i].score[1]+stu[i].score[2])/3.0;
    }
}
struct Student max(struct Student stu[])
{
    int i,m=0;
    for(i=0;i<N;i++)
        if(stu[i].aver>stu[m].aver) m=i;
        return stu[m];
}
void print(struct Student stud)
{
    printf("\n成绩最高的学生是:\n");
    printf("学号：%d\n姓名：%s\n三门课成绩:%5.1f,%5.1f,%5.1f\n平均成绩：%6.2f\n"
           ,stud.num,stud.name,stud.score[0],stud.score[1],stud.score[2],stud.aver);
}
int main()
{
    struct Student stu[N],*p=stu;
    input(p);
    print(max(p));
    return 0;
}*/

开学的第十三个晚上 3月22号
谭书就剩链表后面的部分了，楼主决定开始cpp了 ，此贴终结吧，哈哈
//星期日
//链表是一种动态分配储存的一种数据结构，
//链表种每一个元素称为结点，分为两部分，一是用户需要用的实际数据：二是下一个结点的地址
//表为地址放一个NULL，表示链表到此结束
//链表中各元素内存地址可以是不连续的
/*c语言的指针部分 *p与p区别
p是指针变量，其值是一个变量的地址。p收到了哪个变量的地址，就指向哪个变量。该变量成为p的对象。
*p是p所指向的对象的值。
例如：int   i=3,*p;
          p=&i;           注意：p收到i的地址，故p指向i，i是p的对象
          printf("%d,%d\n",i,*p);         输出：3,3      注意：*p是p所指向的对象的值，即i的值。
*/
//p是一个地值    *p是这个地址中的数据
/*
struct Student
{int num;
float score;
struct Student*next;
};
int main()
{
    struct Student a,b,c,*head,*p;//定义三个结构体变量a,b,c作为链表的结点:(用户所需数据，下一个结点地址)
    a.num=10101; a.score=89.5;//对结点a的num和score成员赋值
    b.num=10103; b.score=90;//对结点b的num和score成员赋值
    c.num=10107; c.score=85;
    head=&a;//将接点a的起始地址赋给指针变量head        *p是p所指向的对象的值。   
    a.next=&b;//将结点b的起始地址赋给a结点的next的成员
    b.next=&c;//将结点c的起始地址赋给b结点的next的成员
    c.next=NULL;//将尾部NULL空地址赋给c结点的next成员  ，不存放其他结点地址表示结束
    p=head;//使指针变量p也指向a的地址
    do                                          // 第一个(*p).num可理解为对p所指地址上的num数据进行读写操作
    {                                          //c语言中允许把(*p).num用p->num代替 等价于stu.num
        printf("%ld %5.1f\n",p->num,p->score);//输出p指向结点的数据   
        p=p->next;//p指向下一结点
    }while(p!=NULL);//输出完c结点后p值为NULL，循环终止
    return 0;
}*///如p->num值为10101
//(++p)->num  先使p自加1,然后得到p指向元素中的num成员值(10102)
//(p++)->num 先求p->num的值(10101) 在使p自加1
#include<stdlib.h>
#define LEN sizeof(struct Student)
//LEN代表struct Student类型的数据长度 sizeof是求字节运算符
struct Student
{
    long num;
    float score;
    struct Student*next;
};
int n;//全局变量 本文件模块的各函数均可使用
struct Student*creat(void)//相当于 int* 函数名(void)
//这里struct student是类型，*表示是指针，也就是说函数create（）返回值是一个struct student类型的指针。
//void表明没有参数，可以不写。
{
    struct Student*head;//定义指向该结构体对指针head
    struct Student*p1,*p2;//定义指向该结构体指针p1 p2    p1 p2是指向struct Student类型数据的指针变量
    n=0;
    // C语言中，连续赋值是从右到左进行的
    p1=p2=(struct Student*) malloc(LEN);//malloc(LEN)作用是开辟一个长度为LEN的内存区（堆空间）
//      这句代码的执行顺序为：          //(struct Student)的作用是malloc返回的指针转换为struct Student类型数据的指针 （*不能省略）
//      1.获取Student结构体所需的内存空间大小；  
//        2.向系统申请第1步获得的大小的内存空间，并取得指向这个空间的指针；
//        3.将指向这个空间的指针强制转化为一个Student结构体类型的指针；   
//        4.将这个指针赋值给p2；  
//        5.将p2赋值给p1
    scanf("%ld,%lf",&p1->num,&p1->score);//把学号和成绩放到结构体指针p1所指num 与score的地址上
    //%f代表按实型输入或输出，而%lf代表按双精度输入或输出
    head=NULL;//让head指针指向空地址  清空
    while(p1->num!=0)//当检测p1指向结构体成员num上的值不等于0时
    {
        n=n+1;
        if(n==1) head=p1;//head指向p1
        else p2->next=p1;//next指向p1
        p2=p1;
        p1=(struct Student*) malloc(LEN);
        scanf("%ld,%f",&p1->num,&p1->score);
    }
    p2->next=NULL;
        return(head);
}
int main()
{
    struct Student*pt;
    pt=creat();
    printf("\nnum:%ld\nscore:%5.1f\n",pt->num,pt->score);
    return 0;
}
希望楼主的C语言能够继续坚持下去