1 struct student
 2 { 3 　　char name;
 4 　　int age;
 5 　　float score;6 };

 1 #include<stdio.h>
 2 #include<string.h>
 3 #define MAX 101
 4 struct aa
 5 {
 6 　　char name[15];
 7 　　char tel[15];
 8 };
 9 int readin(struct aa *a)
10
11 //注意这里结构体aa的变量名为*a，是一个指针，因为这个结构体在三个函数中均被调用。所以只有使用指针才较为便利地可以实现函数间大量数据的调用。
12
13 //其实，在使用指针为变量时，就已经建立了一个以a为名的aa型结构体数组了。
14
15 {
16 　　int i=0,n=0;
17 　　while(1)
18
19 　　//本人最为喜欢的循环体设置方法，包括for(;1;)的设立，循环体中再建立相关判断条件。
20 　　{
21 　　　　scanf("%s",a[i].name);
22 　　　　if(!strcmp(a[i].name,"#"))
23
24 　　　　//利用这样的判断语句判断输入是否为#，（其实可以在判断语句中实现赋值与判断的共同实现，虽然好看，但是确保自己逻辑正确。）
25
26 　　　　//strcmp()比较两个字符串是否相等，相等返还0，相等返还0，相等返还0.
27 　　　　　　break;
28 　　　　scanf("%s",a[i].tel);
29 　　　　i++;
30 　　　　n++;
31 　　}
32 　　return n;
33
34 　　//返回输入结构体的数量。（一组数据就是一个结构体）
35 }
36 void search(struct aa *b,char *x,int n)
37
38 //x是一个指针，主函数中name是数组名，即一个指针。
39 {
40 　　int i;
41 　　i=0;
42 　　while(1)
43 　　{
44 　　　　if(!strcmp(b[i].name,x))
45 　　　　{
46 　　　　　　printf("name:%s    　　　　    tel:%s\n",b[i].name,b[i].tel);
47 　　　　　　break;
48 　　　　}
49 　　　　else
50 　　　　　　i++;
51 　　　　n--;
52
53 　　　　//其实这个n是用来计算是否所有结构体遍历。但是我认为用i就行了。虽然i是在判断语句里面，但这个语句在没找到目标是是一直执行的，如同在外面和n相同待遇
54
55 　　　　//当判断语句找到目标时，那就更不需要他了。因为程序结束了。
56
57 　　　　if(n==0)
58 　　　　{
59 　　　　　　printf("No found!");
60 　　　　　　break;
61 　　　　}
62 　　}
63 }
64 main()
65 {
66 　　struct aa s[MAX];
67 　　int num;
68 　　char name[15];
69 　　num=readin(s);
70
71 　　//这个语句有两个用处，1.将readin函数返回给num；2.readin函数将数据存储于数组s。
72 　　printf("input the name:");
73 　　scanf("%s",name);
74 　　search(s,name,num);
75 }

 1 #include<stdio.h>
 2 #include<malloc.h>
 3 //malloc是用来划分存储空间的函数。
 4 struct LNode
 5 {
 6 　　int data;
 7 　　struct LNode *next;
 8 　　//指向下一个的结构体。从而形成链表。
 9 };
10 struct LNode *create(int n)
11 {
12 　　int i;
13 　　struct LNode *head,*p1,*p2;
14 　　//head表示头节点。p1，实现存储空间的获取，数据域赋值等。p2，作为与p1的中间指针，构成链表的替换连接。
15 　　int a;
16 　　head=NULL;
17 　　//头节点为空。
18 　　printf("Input the integers:\n");
19 　　for(i=n;i>0;--i)
20 　　{
21 　　　　p1=(struct LNode*)malloc(sizeof(struct LNode));
22 　　　　//malloc(sizeof(struct LNode)表示划分LNode大小的存储空间。
23 　　　　//(struct LNode*)表示数据类型的转换，将划分来的存储空间首地址转化为LNode的变量名（指针类型）。
24 　　　　scanf("%d",&a);
25 　　　　p1->data=a;
26 　　　　//向p1的结构体中存储数据。
27 　　　　if(head==NULL)
28 　　　　{
29 　　　　　　head=p1;
30 　　　　　　p2=p1;
31 　　　　　　//对头节点的处理。
32 　　　　}
33 　　　　else
34 　　　　{
35 　　　　　　p2->next=p1;
36 　　　　　　//表明p2的下一个节点是p1。其中p2是上个循环中的p1。也就是说，p2只是一个中间变量temp。
37 　　　　　　p2=p1;
38 　　　　　　//印证了上个注释中，p2的由来。
39 　　　　　　//具体的过程在变量名的说明中就已经体现了。
40 　　　　}
41 　　}
42 　　p2->next=NULL;
43 　　//最后一个节点的指针域为空，作为结束的标志。
44 　　return head;
45 　　//返回代表头结点的结构体的变量名（指针）。
46 }
47 void main()
48 {
49 　　int n;
50 　　struct LNode *q;
51 　　printf("Input the count of the nodes you want to creat:");
52 　　scanf("%d",&n);
53 　　q=create(n);
54 　　//输入，返回。
55 　　printf("The result is:\n");
56 　　while(q)
57 　　//q只有到了最后一个节点的next时，为NULL，才会跳出循环。一个很有用的小技巧。
58 　　{
59 　　printf("%d    ",q->data);
60 　　q=q->next;
61 　　//实现q的转换，从而输出所有数据。
62 　　}
63 　　getch();
64 }

  1 #include<stdio.h>
  2 typedef struct node
  3 {
  4 　　char name[20];
  5 　　struct *prior,*next;
  6 　　//设立节点的前驱节点和后继结点。
  7 }stud;
  8 stud *creat(int n)
  9 {
 10 　　stud *p,*h,*s;
 11 　　int i;
 12 　　h=(stud*)malloc(sizeof(stud));
 13 　　//申请存储空间
 14 　　h->name[0]='\0';
 15 　　//设置name为空
 16 　　h->prior=NULL;
 17 　　h->next=NULL;
 18 　　p=h;
 19 　　for(i=0;i<n;i++)
 20 　　{
 21 　　　　s=(stud*)malloc(sizeof(stud));
 22 　　　　p->next=s;
 23 　　　　printf("Input the %d student'sname:",i+1);
 24 　　　　scanf("%s",s->name);
 25 　　　　s->prior=p;
 26 　　　　s->next=NULL;
 27 　　　　p=s;
 28 　　　　//方法和单向链表没什么区别，区别只在于多了一个前驱节点的设置。
 29 　　　　//从一些方面来说，多了前驱节点更容易理解了。
 30 　　}
 31 　　p->next=NULL;
 32 　　//设置最后节点的后继结点为空，作为结束标志。
 33 　　return(h);
 34 }
 35 stud *search(stud *h,char *x)
 36 {
 37 　　stud *p;
 38 　　char *y;
 39 　　p=h->next;
 40 　　while(p)
 41 　　{
 42 　　　　y=p->name;
 43 　　　　if(strcmp(y,x)==0)
 44 　　　　//判断是否为寻找的目标。
 45 　　　　　　return(p);
 46 　　　　　　//返回目标地址。
 47 　　　　else
 48 　　　　　　p=p->next;
 49 　　　　　　//继续下一个节点的检测。
 50 　　}
 51 　　printf("cannot find data!\n");
 52 　　//没有任何符合条件的返回。
 53 }
 54 void del(stud *p)
 55 {
 56 　　p->next->prior=p->prior;
 57 　　//令p的下一个节点的前驱节点与现在p的前驱节点一致（这样在前驱节点中p就不存在了。并且链表没有断开。）
 58 　　p->prior->next=p->next;
 59 　　//令p的前一个节点的后继结点与现在p的后继结点一致（这样在后街节点中p就不存在了。并且链表没有断开。）
 60 　　//切记：p->next是指p的后一个节点。p->prior同理。
 61 　　//无法理解的话，请在草稿纸上画出链表图，就清晰无比了。
 62 　　//这里两句代码在有些运行环境中会报错，可以自行更改语句或环境。
 63 　　free(p);
 64 　　//释放p的存储空间（链表上p已经不存在了。当然不能让它占着空间了）
 65 }
 66 main()
 67 {
 68 　　int number;
 69 　　char sname[20];
 70 　　stud *head,*sp;
 71 　　puts("Please input the size of the list:");
 72 　　scanf("%d",&number);
 73 　　head=creat(number);
 74 　　sp=head->next;
 75 　　printf("\nNow the double list is:\n");
 76 　　while(sp)
 77 　　{
 78 　　　　printf("%s",&*(sp->name));
 79 　　　　sp=sp->next;
 80 　　}
 81 　　//之前的都与单向链表相同。
 82 　　printf("\nPlease input the name which you want to find:\n");
 83 　　scanf("%s",sname);
 84 　　sp=search(head,sname);
 85 　　//通过search函数，寻找到所要寻找的sname的地址sp。
 86 　　printf("the name you want to find is:\n",*&sp->name);
 87 　　del(sp);
 88 　　//将sp带入到del()函数中，删除。
 89 　　sp=head->next;
 90 　　//这句话只是为了下面的while循环做二次利用的。完全可以删除这句话，为下面的循环单独设置一个变量。
 91 　　printf("\nNow the double list is:\n");
 92 　　while(sp)
 93 　　{
 94 　　　　printf("%s",&*(sp->name));
 95 　　　　sp=sp->next;
 96 　　}
 97 　　printf("\n");
 98 　　puts("\nPress any key to quit...");
 99 　　getch();
100 　　//与单向链表相同的输出原理。
101 }

 1 stud *reverse(stud *head)
 2 {
 3 　　stud *p,*r,*h;
 4 　　h=head->next;
 5
 6 　　//设置h。
 7 　　if(h&&h->next)
 8 　　{
 9 　　　　p=h;
10 　　　　r=p->next;
11 　　　　p->next=NULL;
12 　　　　while(r)
13 　　　　{
14 　　　　　　p=r;
15 　　　　　　r=r->next;
16 　　　　　　p->next=h;
17 　　　　　　h->prior=p;
18 　　　　　　h=p;
19
20 　　　　　　//中间变量p，变量r从链表的头部向后遍历，变量h从链表的尾部向前遍历。变量p作为中间变量来转移指针地址，完成链表逆置。
21 　　　　}
22 　　　　head->next=h;
23 　　　　h->prior=head;
24
25 　　　　//事后，完成链表的补全。即链表的开头和结尾。
26 　　　　return head;
27 　　}
28 }