小问题谁来帮我？

364904690

       输出链表数据的print函数中，head指针已经移动到链表的末尾，为什么退出本次调用，下次再次调用print函数时，head指针仍然能从链表头节点开始输出。本人理解，在第二次调用前，首先要使head指针返回链表头结点。可是在这儿，没有再次赋值使head回到表头，但它确实是从表头开始输出的，想不明白！

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #define LEN sizeof(struct node)
   
5. 
   
6. struct node    //定义节点
   
7. {
   
8.         char data;
   
9.         struct node *next;
   
10. } *p, *q, *r,*t,*head;  
    
11. 
    
12. struct node *creat()     //创建4个链表节点并初始化
    
13. {
    
14.         p=(struct node *)malloc(LEN);    //开辟4个节点p,q,r,t
    
15.         q=(struct node *)malloc(LEN);
    
16.         r=(struct node *)malloc(LEN);
    
17.         t=(struct node *)malloc(LEN);
    
18.         p->data='A';   //初始化节点数据域
    
19.         q->data='B';
    
20.         r->data='C';
    
21.         t->data='D';
    
22.         p->next=q;    //建立链接
    
23.         q->next=r;
    
24.         r->next=t;
    
25.         t->next=NULL;
    
26.         head=p;
    
27.         return (head);
    
28. }
    
29. 
    
30. void print(struct node *head)  //输出链表数据
    
31. {
    
32.         do
    
33.         {
    
34.                 printf("%c ",head->data);
    
35. 
    
36.                 head=head->next ;   // 问题在这儿，问题在这儿
    
37.         } while(head!=NULL);
    
38.         printf("\n\n");
    
39. }
    
40. 
    
41. struct node * change(struct node *head)  //更改节点顺序，将原来的A-B-C-D变为A-C-B-D
    
42. {
    
43.         q->next=r->next;
    
44.         p->next=r;
    
45.         r->next=q;
    
46.         return (head);
    
47. }
    
48. 
    
49. int main()
    
50. {
    
51. 
    
52.         struct node *head;
    
53.         head=creat();
    
54.         print(head);
    
55.         head=change(head);
    
56.         print(head);
    
57.         return 0;
    
58. }
    

复制代码

仰望天上的光

前面几位朋友基本都说出问题的本质了，我来总结一下。
在C语言中，函数的参数都是值传递，所以，如函数调用 f1(a);调用后肯定不可能改变a的值，同理，f1(&a)调用后，也绝对不可能改变&a的值，但有可能改变a的值。

OK，说你的疑问。从形式上看，函数调用print(head);绝对不可能改变head的值，而前面版主写的print(&head);虽然不糊会改变&head的值，但有可能改变head的值。

最后，这其实是一个非常常见的问题，希望LZ充外在形式上开这个问题，不必纠结前面例子中f1(a)中a是不是指针类型；或者print(&head)中head是不是指针类型。无论这些参数是什么类型，以上的形式都是成立的。

迪拜~战阳

函数里面结构接收函数外面的的结构进行索引，怎么会修改函数外面的索引头呢？
你只是在函数里做了一个，跟函数外面的结构的名字一样的结构而已

迪拜~战阳

head=head->next修改函数里面的head，不修改函数外面的head

ryxcaixia

#include <stdio.h>
#include <stdlib.h>
#define LEN sizeof(struct node)

struct node    //定义节点
{
        char data;
        struct node *next;
} *p, *q, *r,*t,*head;  

struct node *creat()     //创建4个链表节点并初始化
{
        p=(struct node *)malloc(LEN);    //开辟4个节点p,q,r,t
        q=(struct node *)malloc(LEN);
        r=(struct node *)malloc(LEN);
        t=(struct node *)malloc(LEN);
        p->data='A';   //初始化节点数据域
        q->data='B';
        r->data='C';
        t->data='D';
        p->next=q;    //建立链接
        q->next=r;
        r->next=t;
        t->next=NULL;
        head=p;
        return (head);
}

void print(struct node *head)  //输出链表数据
{
        do
        {
                printf("%c ",head->data);

                head=head->next ;   // 问题在这儿，问题在这儿
        } while(head!=NULL);
        printf("\n\n");
}

void print(struct node** head)  //输出链表数据
{
        do
        {
                printf("%c ", (*head)->data);

                *head=(*head)->next ;   // 问题在这儿，问题在这儿
        } while(*head!=NULL);
        printf("\n\n");
}


struct node * change(struct node *head)  //更改节点顺序，将原来的A-B-C-D变为A-C-B-D
{
        q->next=r->next;
        p->next=r;
        r->next=q;
        return (head);
}

int main()
{

        struct node *head;
        head=creat();
        print(&head);
        head=change(head);
        print(&head);
        return 0;
}
按照红色的部分的 能达到楼主的效果 不过代码运行会出错 因为第一次的print已经到表尾

任何变量(包括指针)作为参数在函数之间传递时, 编译器都会默认创建一个临时变量
你在函数内部修改的仅仅是这个临时变量 楼主对这个临时变量的位置进行了修改 但是函数体结束时
这个临时变量就会消失 而外部的变量 并没有得到实质的变化

函数体内想要对外部的指针变量进行实际操作, 要么传指针的引用 要么传递二级指针
建议楼主看看经典的swap函数 进行下深刻的理解传值和传址的区别

qq334121747

呵呵。。。。。。

qq334121747

刚刚在vc++6.0中编译居然是正确的。。。。。。

阔怀

仔细看看链表的章节

默默路过

正如版主说的那样，函数的形式参数 可以看做函数的 局部变量，在函数调用初始的时候，使用外部实参 初始化形参，初始化结束以后所有的修改都是 针对形参完成的，与实参没有任何关系，这样的初始化方式是值传递；使用指针或者引用的方式才能达到改变实参的效果，这是地址传递；
比如 int a = 20；
        int b = a；
后面对 b 的修改 不会影响a；
     而int& c = a；或者 int* d = &a；
修改c = 14 或者对 *b =15 赋值的时候 a 就被改变了；
基本就是这个意思了！一个是使用 内存中的值 去初始化 另一个内存的值（他们是同级的），一个是使用 内存地址 去初始化另一个内存的值（后一个是前一个的指针）