关于C语言指针的写法 ：x-y->z范式的

text6789

1. #include   <stdio.h>
   
2. #include   <string.h>
   
3. #include   <stdlib.h>
   
4. #include   <conio.h>
   
5. 
   
6. /*定义全局变量*/
   
7. #define   TRUE   1
   
8. #define   FALSE   0
   
9. #define   OK   1
   
10. #define   ERROR   0
    
11. #define   NULL   0
    
12. #define   OVERFLOW   -2
    
13. #define   MAXSIZE   100
    
14. #define   stack_init_size   100
    
15. #define   stackincrement   10
    
16. typedef   char   selemType;
    
17. typedef   char   qelemType;
    
18. typedef   char   elemType;
    
19. typedef   int   status;
    
20. char   e;     
    
21. char   demon[MAXSIZE];
    
22. 
    
23. /* 类型及其基本操作*/   
    
24. typedef   struct   
    
25. {   
    
26.         selemType   *base;
    
27.         selemType   *top;
    
28.         int   stacksize;
    
29. }sqstack;     
    
30. status   initstack   (sqstack   *s)
    
31. {     
    
32.         s->base=(selemType   *)malloc(stack_init_size*sizeof(selemType));     
    
33.         if(!s->base)   exit   (OVERFLOW);
    
34.         s->top=s->base;
    
35.         s->stacksize=stack_init_size;
    
36.         return   OK;
    
37. }/*创建栈*/
    
38. status   push   (sqstack   *s,selemType   e)
    
39. {
    
40.         if(s->top-s->base>=s->stacksize)
    
41.         {
    
42.                 s->base=(elemType*)   realloc(s->base,(s->stacksize+stackincrement)*sizeof(elemType))     
    
43.                 if(!s->base)   exit(OVERFLOW);
    
44.                 s->top=s->base+s->stacksize;
    
45.                 s->stacksize+=stackincrement;
    
46.         }
    
47.         *(s->top++)=e;
    
48.         return   OK;
    
49. }/*入栈*/
    
50. status   pop(sqstack   *s,selemType   *e)
    
51. {     
    
52.         if(s->top==s->base)   return   ERROR;
    
53.         *e=*(--(s->top));
    
54.         return   OK;
    
55. }/*出栈*/
    
56. /*队列类型及其基本操作*/
    
57. typedef   struct   qnode
    
58. {
    
59.         qelemType   data;
    
60.         struct   qnode   *next;
    
61. }qnode,*queueptr;
    
62. typedef   struct
    
63. {
    
64.         queueptr   front;
    
65.         queueptr   rear;
    
66. }linkqueue;
    
67. status   initqueue(linkqueue   *q)
    
68. {
    
69.         q->front=q->rear=(queueptr)malloc(sizeof(qnode));
    
70.         if(!q->front)   exit(OVERFLOW);
    
71.        q->front->next=NULL;
    
72.         return   OK;
    
73. }/*创建队列*/
    
74. status   enqueue(linkqueue   *q,qelemType   e)
    
75. {
    
76.         queueptr   p;
    
77.         p=(queueptr)malloc(sizeof(qnode));
    
78.         if(!p)   exit(OVERFLOW);
    
79.         p->data=e;
    
80.         p->next=NULL;
    
81.        <font color="#ff0000">q->rear->next=p; </font>
    
82.         q->rear=p;
    
83.         return   OK;
    
84. }/*入队*/
    
85. status   dequeue(linkqueue   *q,qelemType   *e)
    
86. {
    
87.         queueptr   p;
    
88.         if(q->front==q->rear)   return   ERROR;
    
89.         p=q->front->next;
    
90.         *e=p->data;
    
91.       <font color="#ff0000"> q->front->next=p->next; </font>
    
92.         if(q->rear==p)
    
93.         {
    
94.                 q->rear=q->front;
    
95.         }
    
96.         free(p);
    
97.         return   OK;
    
98. }/*出队*/
    
99. /*括号内元素入栈处理函数*/
    
100. void   tempstack(sqstack   *temps)
     
101. {
     
102.         int   i=0;
     
103.         char   t;
     
104.         char   c;
     
105.         c=demon;
     
106.         for(i=0;c!='#';i++)/*遍历数组*/
     
107.         {
     
108.                 c=demon;
     
109.                 if(c=='(')/*遇到开括号*/
     
110.                 {
     
111.                         t=demon[i+1];/*取括号中的首字母*/
     
112.                         push(temps,t);/*入栈*/
     
113.                         i++;/*指向首字母*/
     
114.                         do
     
115.                         {
     
116.                                 i++;
     
117.                                 c=demon;
     
118.                                 push(temps,c)/*第一次循环将次字母入栈*/;
     
119.                                 push(temps,t);/*再将首字母进栈*/
     
120.                         }while(c!=')');/*直到括号中元素全部进栈*/
     
121.                         pop(temps,&t);/*将多余进栈的首字母t出栈*/
     
122.                         pop(temps,&t);   /*将多余进栈的')'出栈*/
     
123.                 }
     
124.         }
     
125. }/*临时栈*/
     
126. 
     
127. /*特殊入队函数*/
     
128. void   spenqueue(linkqueue   *q,char   key)     
     
129. {     
     
130.         int   j=0;
     
131.         char   a[5];
     
132.         switch(key)   /*判断大写字母对应的字符串*/
     
133.         {
     
134.         case'A':strcpy(a,"ase");break;
     
135.         case'B':strcpy(a,"tAdA");break;
     
136.         case'C':strcpy(a,"abc");break;
     
137.         case'D':strcpy(a,"def");break;
     
138.         case'E':strcpy(a,"ghi");break;
     
139.         case'F':strcpy(a,"klm");break;
     
140.         case'H':strcpy(a,"mop");break;
     
141.         default:strcpy(a,"???");   /*不能翻译的魔王语言以"???"输出*/
     
142.         }
     
143.         while(a[j]!='\0')   /*如果数组还有字母*/
     
144.         {
     
145.                 enqueue(q,a[j]);/*进队*/
     
146.                 j++;
     
147.         }
     
148. }/*特殊入队*/
     
149. /*排序入队处理函数*/
     
150. status   sort(sqstack   *s,linkqueue   *q)
     
151. {     
     
152.         qnode   b;
     
153.         int   flag=0;/*大写字母监视哨置零*/
     
154.         int   i;
     
155.         for(i=0;demon[   i]!='#';i++)/*遍历数组*/
     
156.         {
     
157.                 b.data=demon[   i];
     
158.                 if(   ('a'<=b.data&&b.data<='z')||b.data=='?')   /*如果是小写字母或者'?'　则直接进栈*/     
     
159.                 {
     
160.                         enqueue(q,b.data);
     
161.                 }
     
162.                 else
     
163.                 {
     
164.                         if('A'<=b.data&&b.data<='Z')   /*如果是大写字母,则调用特殊进栈函数,*/     
     
165.                         {
     
166.                                 spenqueue(q,b.data);
     
167.                                 flag=1;   /*发现大写字母监视哨置1*/
     
168.                         }
     
169.                         else
     
170.                         {
     
171.                                 if(b.data=='(')/*如果是括号*/
     
172.                                 {
     
173.                                         do
     
174.                                         {
     
175.                                                 pop(s,&e);
     
176.                                                 enqueue(q,e);
     
177.                                         }while(!(s->top==s->base));   /*只要栈不为空,则出栈进队*/     
     
178.                                         while   (b.data!=')')   /*只要还指向括号内元素,就继续往后移,保证原括号内的元素不再进栈*/
     
179.                                         {
     
180.                                                 i++;
     
181.                                                 b.data=demon;
     
182.                                         }
     
183.                                 }
     
184.                         }
     
185.                 }
     
186.         }
     
187.         return   flag;
     
188. }/*排序*/
     
189. /*主函数*/
     
190. status   main()
     
191. {
     
192.         sqstack   s1;
     
193.         linkqueue   q1;
     
194.         int   k=0;
     
195.         int   flag=1;
     
196.         clrscr();
     
197.         printf("Please   Input   the   Demon's   Words:\n");
     
198.         printf("!:   Less   Than   30   Letters:   )\n");
     
199.         printf("!:   End   with   '#':   )\n\t");
     
200.         scanf("%s",demon);
     
201.         printf("\n***************************************");
     
202.         initstack(&s1);   /*创建栈*/
     
203.         initqueue(&q1);   /*创建队*/
     
204.         tempstack(&s1);   /*调用函数*/
     
205.         while   (flag==1)   /*如果有大写字母*/
     
206.         {
     
207.                 k=0;
     
208.                 flag=sort(&s1,&q1);
     
209.                 while(q1.front!=q1.rear)   /*重写demon[i   ]*/
     
210.                 {
     
211.                         dequeue(&q1,&e);
     
212.                         demon[k]=e;
     
213.                         k++;
     
214.                 }
     
215.                 demon[k]='#';
     
216.         }
     
217.         demon[k]='\0';
     
218.         printf("\n***************************************");
     
219.         printf("\nThe   Human   Words:\n\t%s",demon);
     
220.         printf("\n***************************************");
     
221. }

复制代码

[i][i][i]
---------------------------------------------------------------------------------------------------------------------------------------
以上是别人的写法；
平时定义一个结构体变量的是:
struck arg{int a; int b;}ARG   struck arg *point; point->a;这种-> 的写法是一个指向；
而上面的链表数据为什么有连续的->x->x1->x2的写法呢？
其中上面的一个范例过程源码写法：q->front->next=p->next;   是什么意义？有和数据的指向？

[/i][/i][/i]

machimilk

q->front->next=p->next;  你可以简单的理解为q的前节点指向的后节点原本是q现在 把它改成了指向p的后节点

text6789

machimilk 发表于 2014-11-5 15:14
q->front->next=p->next;  你可以简单的理解为q的前节点指向的后节点原本是q现在 把它改成了指向p的后节点

这样的一个写法读：
1：q->front;//先这样的数据为知道？还是
2：q->front->next;还不能会意您的意思；

text6789

machimilk 发表于 2014-11-5 15:14
q->front->next=p->next;  你可以简单的理解为q的前节点指向的后节点原本是q现在 把它改成了指向p的后节点

不错，到今天理解了，门外汉站了好久才知道这个循环链表里面的q->font->next指针指向的节点的下一个节点