C语言:链表的逆置

输入若干个不超过100的整数,建立单链表,然后将链表中所有结点的链接方向逆置,要求仍利用原表的存储空间。输出逆置后的单链表。
输入格式:
首先输入一个整数T,表示测试数据的组数,然后是T组测试数据。每组测试数据在一行上输入数据个数n及n个不超过100的整数。
输出格式:
对于每组测试,输出逆置后的单链表,每两个数据之间留一个空格。
输入样例:
1
11 55 50 45 40 35 30 25 20 15 10 5
输出样例:
5 10 15 20 25 30 35 40 45 50 55

#include<stdio.h>
#include<stdlib.h>
typedef struct node{
    int data;
    struct node* next;
}list;

list* getlist(int num){
    //接收个数

    list *head,*tail,*datanode;
    int dat=0;
    head=(list*)malloc(sizeof(list));
    tail=head;
    while(num>0){
        scanf("%d",&dat);
        datanode=(list*)malloc(sizeof(list));
        datanode->data=dat;
        tail->next=datanode;//注意是把新数据的地址赋给tail指针,实现tail的next指向新数据
        tail=datanode;//注意是把新数据的地址赋给tail,实现tail指向新数据
        num--;
    }
    datanode->next=NULL;
    return head->next;
}


void reverse(list *l1,list *l2,int num) {
    int temp;
    while (num>0)
    {
        temp=num;
        l1=l2;
        while(temp>1){
            l1=l1->next;
            temp--;
        }
        printf("%d",l1->data);
        if(num>1){
            printf(" ");
        }
        num--;
    }
}


int main(){
    int group,n=0;
    int num;
    scanf("%d",&group);

    while(group>0)
    {
        list *l1,*l2;
        scanf("%d",&num);
        l1=getlist(num);
        l2=l1;
        reverse(l1,l2,num);
        printf("\n");
        group--;
    }

    return 0;
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 链表逆置头插法的C语言实现如下: ``` #include <stdio.h> #include <stdlib.h> typedef struct node { int data; struct node *next; } Node, *LinkList; LinkList reverse(LinkList head) { Node *p, *q; p = NULL; while (head) { q = head->next; head->next = p; p = head; head = q; } return p; } int main() { int i; Node a[10]; LinkList head, p; for (i = 0; i < 10; i++) { a[i].data = i; a[i].next = &a[i + 1]; } a[9].next = NULL; head = &a[0]; head = reverse(head); p = head; while (p) { printf("%d ", p->data); p = p->next; } return 0; } ``` ### 回答2: 链表的头插法是将新节点插入链表的头部,逆置链表的头插法则是将原链表的节点从头到尾一个个取出,依次插入到一个新链表的头部。 在C语言链表节点的定义通常如下: ```c typedef struct Node { int data; // 节点数据 struct Node* next; // 下一个节点的指针 } Node; ``` 我们可以编写一个名为`reverseList`的函数来实现链表逆置头插法,代码如下: ```c #include <stdio.h> #include <stdlib.h> // 链表节点定义 typedef struct Node { int data; // 节点数据 struct Node* next; // 下一个节点的指针 } Node; // 创建新节点 Node* createNode(int data) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = data; newNode->next = NULL; return newNode; } // 逆置链表的头插法 Node* reverseList(Node* head) { Node* newHead = NULL; // 新链表的头指针 Node* temp; while (head != NULL) { temp = head->next; // 保存下一个节点的指针 head->next = newHead; // 将当前节点插入到新链表的头部 newHead = head; // 更新新链表的头指针 head = temp; // 移动原链表的指针到下一个节点 } return newHead; // 返回逆置后的链表头指针 } // 输出链表数据 void printList(Node* head) { Node* current = head; while (current != NULL) { printf("%d ", current->data); current = current->next; } printf("\n"); } int main() { Node* n1 = createNode(1); Node* n2 = createNode(2); Node* n3 = createNode(3); Node* n4 = createNode(4); n1->next = n2; n2->next = n3; n3->next = n4; printf("原链表:"); printList(n1); Node* newHead = reverseList(n1); printf("逆置链表:"); printList(newHead); return 0; } ``` 以上代码的输出结果为: ``` 原链表:1 2 3 4 逆置链表:4 3 2 1 ``` 在这个例子,原链表的节点1、2、3、4被逆置后的新链表的头部插入,得到的新链表的节点为4、3、2、1。 ### 回答3: 链表逆置是指将链表结点顺序颠倒。头插法逆置链表是一种常用的方法。假设链表的定义如下: ```c struct Node { int data; struct Node* next; }; ``` 使用头插法逆置链表的步骤如下: 1. 初始化一个空链表newList,新链表的头结点指针为NULL。 2. 遍历原链表,逐个取出结点。 3. 对于每个取出的结点,创建一个新结点,并将新结点的值赋为取出结点的值。 4. 将新结点的next指针指向newList的头结点(原头结点的后继结点)。 5. 更新newList的头结点为新结点。 6. 重复步骤2-5直到原链表的所有结点都取出并插入到newList。 7. 返回newList作为逆置后的链表。 以下是使用C语言实现链表逆置的代码示例: ```c #include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node* next; }; struct Node* reverseList(struct Node* head) { struct Node* newList = NULL; while(head != NULL) { struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->data = head->data; newNode->next = newList; newList = newNode; head = head->next; } return newList; } int main() { struct Node node1, node2, node3; struct Node* head; node1.data = 1; node2.data = 2; node3.data = 3; node1.next = &node2; node2.next = &node3; node3.next = NULL; head = &node1; printf("原链表:"); struct Node* p = head; while(p != NULL) { printf("%d ", p->data); p = p->next; } printf("\n"); head = reverseList(head); printf("逆置后的链表:"); p = head; while(p != NULL) { printf("%d ", p->data); p = p->next; } printf("\n"); return 0; } ``` 运行该程序会输出如下结果: ``` 原链表:1 2 3 逆置后的链表:3 2 1 ``` 以上就是使用C语言实现链表逆置的头插法。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值