[已解决]关于链表 救救孩子吧

youxixingzhet

#include <stdio.h>
#include <stdlib.h>
   
struct Node
{
        int value;
        struct Node *next;
};
   
void insertNode(struct Node **head, int value)
{
        struct Node *pre;
        struct Node *cur;
        struct Node *new;
   
        cur = *head;
        pre = NULL;
   
        while (cur != NULL && cur->value < value)
        {
                pre = cur;
                cur = cur->next;
        }
   
        new = (struct Node *)malloc(sizeof(struct Node));
        if (new == NULL)
        {
                printf("内存分配失败！\n");
                exit(1);
        }
   
        new->value = value;
        new->next = cur;
   
        if (pre == NULL)
        {
                *head = new;
        }
        else
        {
                pre->next = new;
        }
}
   
void printNode(struct Node *head)
{
        struct Node *cur;
   
        cur = head;
        while (cur != NULL)
        {
                printf("%d ", cur->value);
                cur = cur->next;
        }
        putchar('\n');
}
   
struct Node *deleteDup(struct Node *head)
{
        if(head == NULL)
        {
                return head;
        }
   
        struct Node *cur = head;
        while (cur->next)
        {
                if (cur->value == cur->next->value)
                {
                        cur->next = cur->next->next;
                }
                else
                {
                        cur = cur->next;
                }
        }
   
        return head;
}
   
int main(void)
{
        struct Node *head = NULL;
        struct Node *new = NULL;
        int input;
   
        while (1)
        {
                printf("请输入一个整数(输入-1表示结束)：");
                scanf("%d", &input);
                if (input == -1)
                {
                        break;
                }
                insertNode(&head, input);
        }
   
        printf("输入的单链表是：");
        printNode(head);
        printf("去重之后的单链表是：");
        new = deleteDup(head);
        printNode(new);
   
        return 0;
}

没有想通为什么deleteDup这个函数里返回head  head在这个函数里没有做处理啊  将地址值赋值给cur 通过逻辑确实能将重复的地方给抹去 但是好像返回head 这不就是怎么传进来 怎么传出去嘛

大神们给解答一下！

最佳答案

月排行榜 / 总排行榜

jhq999

2022-5-31 11:23:03

youxixingzhet 发表于 2022-5-31 10:04
我的意思是 将head这个地址值赋值给cur这个指针   cur这个链表内的地址改变 不会影响head里面的链表  对 ...

head和cur是不同的变量，只不过cur初始值和head相同，head当然不会随cur的改变而改变，同理cur也不会随head的改变而改变

跳转到最佳答案楼层

jhq999

1. struct Node *deleteDup(struct Node *head)
   
2. {
   
3.         if(head == NULL)
   
4.         {
   
5.                 return head;
   
6.         }
   
7.    
   
8.         struct Node *cur = head;
   
9.         while (cur&&cur->next)
   
10.         {
    
11.                 struct Node *p=cur;
    
12.                while (p->next)
    
13.                 {
    
14.                         if(cur->value==p->next->value)
    
15.                         {
    
16.                                 struct Node *tmp = p->next;
    
17.                                 p->next=p->next->next;
    
18.                                 free(tmp);
    
19.                         }
    
20.                         else
    
21.                                 p= p->next;
    
22.                 }
    
23.                 cur = cur->next;
    
24.               
    
25.         }
    
26.    
    
27.         return head;
    
28. }

复制代码

youxixingzhet

jhq999 发表于 2022-5-30 23:11

我的意思是 将head这个地址值赋值给cur这个指针   cur这个链表内的地址改变 不会影响head里面的链表  对嘛？

cur = haed;
cur = cur->next;

head的头指针有跟随cur=cur->next而改变嘛

jhq999

youxixingzhet 发表于 2022-5-31 10:04
我的意思是 将head这个地址值赋值给cur这个指针   cur这个链表内的地址改变 不会影响head里面的链表  对 ...

head和cur是不同的变量，只不过cur初始值和head相同，head当然不会随cur的改变而改变，同理cur也不会随head的改变而改变

Daume

jhq999 发表于 2022-5-31 11:23
head和cur是不同的变量，只不过cur初始值和head相同，head当然不会随cur的改变而改变，同理cur也不会随he ...

按理说： cur = head的时候cur和head指向同一个地址，然后你改变cur的地址就相当于改变了head的地址

jhq999

Daume 发表于 2022-5-31 13:12
按理说： cur = head的时候cur和head指向同一个地址，然后你改变cur的地址就相当于改变了head的地址

看来你还明白指针和指针指向的内容。
head=123；
cur=head;
cur=234;
head还是等于123
至于你说的改变是解引用
head=123；
cur=head;
*head=1;
*cur=2;/////这时候*head=2