将链表转换为反向整数-C

Question

我想将链表转换为反向整数

例如：
LinkedList:3->4->2
输出：243

Eg2:
链接列表：5->6->4
输出：465

布局代码：

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
typedef struct Node{
int val;
struct Node *next;
}node;
int getCount(node* head){ 
} 
int getNumber(node* ptr,int size){

}
int main(){
struct Node * head;
struct Node * second;
struct Node * third;
head = (node*) malloc(sizeof(node));
second = (node*) malloc(sizeof(node));
third = (node*) malloc(sizeof(node));
head->val = 2;     head->next = second;
second->val = 4;   second->next = third;
third->val = 6;    third->next = NULL;
printf("%d",getNumber(head,3));
return 0;
}

Answer 1

您不需要math.h来实现这一点(对于浮点应用程序，您几乎不需要它(。只需遍历列表，每次将添加的下一个节点元素增加为10的幂的倍数(可以通过多种方式实现(。

您不需要getCount。如果列表正确地以null结尾，那么也不需要size参数。见下文：

#include <stdio.h>
#include <stdlib.h>
typedef struct Node
{
int val;
struct Node *next;
} Node;
int getNumber(const Node *ptr)
{
int value = 0;
int exp = 1;
while (ptr)
{
value += ptr->val * exp;
ptr = ptr->next;
exp *= 10;
}
return value;
}
int main()
{
int values[] = {2, 4, 6, 8, 1, 3, 5, 7};
Node *head = NULL; // will hold the list head
Node **pp = &head; // used to build the list
for (size_t i = 0; i < sizeof values / sizeof *values; ++i)
{
*pp = malloc(sizeof **pp);
(*pp)->val = values[i];
pp = &(*pp)->next;
}
*pp = NULL;
// print the resulting number
printf("%dn", getNumber(head));
// free the list;
while (head)
{
void *p = head;
head = head->next;
free(p);
}
return 0;
}

输出

75318642

请注意，当您有不在集合{0...9}中的"术语"(例如：负术语，或值>=10(时，这会变得复杂，但没有提及相关规范或要求。

递归

并不是说任何理智的人都会选择这个，但这是一个微妙的递归算法，可以归结为一个三元表达式，以防你好奇：

int getNumber(const Node *ptr)
{
return ptr ? ptr->val + 10 * getNumber(ptr->next) : 0;
}

Answer 2

因此，我们在这里传递链表的第一个节点及其大小(元素数(，我们也可以使用函数来执行此操作，或者我们可以手动传递大小
函数来获取链表的大小：

int getCount(node* head) 
{ 
int count = 0; // Initialize count 
node* curr = head; // Initialize current 
while (curr != NULL) 
{ 
count++; 
curr = curr->next; 
} 
return count; 
} 

现在我们有了链表的大小
所以现在我们必须完成getNumber函数：

int getNumber(node* ptr,int size){
int sum = 0;
int power;
int a=10;
// i + i*10 + i*100 .....
for(int i=0; i < size; i++){
power = pow(a,i);
sum = sum + ((ptr->val)*power);
ptr = ptr->next;
}
return sum;
}

这里我们使用一个简单的逻辑来获得数字，即我们必须将链表中的第一个数字乘以从零开始的零的幂
即。来自示例1。我们有
LinkedList:3->4->2
输出：243
我们必须将其转换为243所以我们所要做的就是
3*(10^0(+4*(10^1(+3*(10^2(=243
**希望这有帮助
我今天正在寻找这个代码，但在互联网上找不到，所以我创建了一个**
最终代码：

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
typedef struct Node{
int val;
struct Node *next;
}node;
int getCount(node* head){ 
int count = 0; // Initialize count 
node* curr = head; // Initialize current 
while (curr != NULL) { 
count++; 
curr = curr->next; 
} 
return count; 
} 
int getNumber(node* ptr,int size){
int sum = 0;
int power;
int a=10;
// i + i*10 + i*100 .....
for(int i=0; i < size; i++){
power = pow(a,i);
sum = sum + ((ptr->val)*power);
ptr = ptr->next;
}
return sum;
}
int main(){
struct Node * head;
struct Node * second;
struct Node * third;
head = (node*) malloc(sizeof(node));
second = (node*) malloc(sizeof(node));
third = (node*) malloc(sizeof(node));
head->val = 2;     head->next = second;
second->val = 4;   second->next = third;
third->val = 6;    third->next = NULL;
printf("%d",getNumber(head,getCount(head)));
return 0;
}

Answer 3

所以我查看了人们提交的其他答案，发现我不需要使用getcount函数，并修改了我的代码，使其变得更好
最终代码：

#include<stdio.h>
#include<stdlib.h>
typedef struct Node{
int val;
struct Node *next;
}node;
int getNumber(node* ptr){
int sum = 0;
int power = 1;
int a=10;
// i + i*10 + i*100 .....
while(ptr){
sum = sum + ((ptr->val)*power);
ptr = ptr->next;
power *= 10;
}
return sum;
}
int main(){
struct Node * head;
struct Node * second;
struct Node * third;
head = (node*) malloc(sizeof(node));
second = (node*) malloc(sizeof(node));
third = (node*) malloc(sizeof(node));
head->val = 2;     head->next = second;
second->val = 4;   second->next = third;
third->val = 6;    third->next = NULL;
printf("%d",getNumber(head));
return 0;
}