将一个输入的数字颠倒(例如输入12345->54321)

数字颠倒算法实现与应用
本文介绍了一种不使用字符串转换的数字颠倒算法,详细阐述了其实现原理及应用案例,旨在提供一种高效、实用的数字处理方法。

用算法实现将一个输入的数字颠倒(输入12345->54321),要求不调用任何系统函数,也不能将输入的数字转换为字符串作为中间过渡 

 1 //用算法实现将一个输入的数字颠倒(输入12345->54321),要求不调用任何系统函数,也不能将输入的数字转换为字符串作为中间过渡
 2 #include "stdafx.h"
 3 
 4 long reverse(long num)                    
 5 {
 6     long x=0;
 7     while(num)
 8     {
 9         x=x*10;
10         x=x+num%10;
11         num=num/10;
12     }
13     return x;
14 }
15 
16 void main()
17 {
18     long number,rev_num;
19     printf("Please input an integer:\n");
20     scanf("%d",&number);
21     rev_num=reverse(number);
22     printf("The reverse number :%d\n",rev_num);
23 }

 1 //将一个数字颠倒输出,用字符串的方式实现
 2 #include "stdafx.h"
 3 #include <string.h>
 4 
 5 int reverse(char *str)
 6 {
 7     int len=strlen(str);
 8     char *p1=str;
 9     char *p2=str+len-1;
10     while(p1<p2)
11     {
12         char ch;
13         ch=*p1;
14         *p1=*p2;
15         *p2=ch;
16         p1++;
17         p2--;
18     }
19     return 0;
20 }
21 
22 void main()
23 {
24     char str[]="123456";
25     printf("str=%s\n",str);
26     reverse(str);
27     printf("reverse str=%s\n",str);
28 }

 

 

转载于:https://www.cnblogs.com/xingele0917/archive/2012/10/04/2711619.html

#include <iostream> using namespace std; struct Node { int data; struct Node *next; }; //链表结点结构 void createlist_r(struct Node *&head)//尾插法建单链表,没有头结点,输入顺序就是结点顺序 { int n,i; struct Node *p,*tail; head=new Node; cin>>n; cin>>head->data; head->next=nullptr; tail=head; for(i=0; i<n-1; i++) { p=new Node; cin>>p->data; p->next=nullptr; tail->next=p; tail=p; } } void display(struct Node *head)//输出带头结点的单链表 { struct Node *p; p=head; while(p!=nullptr) { cout<<p->data<<" "; p=p->next; } cout<<endl; } void deletelist(struct Node *&head) //删除单链表 { struct Node *p; while(head) { p=head; head=head->next; delete(p); } head=nullptr; //一定要赋值为空,否则容易造野指针访问 } //请在以下空白处编写reverselit函数,完原地逆,即过程中在分配新的结点也撤销旧的结点 /********** Write your code here! **********/ /*******************************************/ int main() { int t; cin>>t; while(t--) { struct Node *head; createlist_r(head); display(head); reverselist(head); display(head); deletelist(head); } return 0; }【id:425】【34分】B. 链表原地逆并输出(填空题) 时间限制 4s 内存限制 128MB 题目描述 按数字输入顺序创建单链表。可借助数组、容器,可开辟新结点空间。编写函数,在原链表上实现单链表的反转。例如单链表10->20->30,反转后变为单链表30->20->10。补全代码
03-20
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> #include <math.h> // 定义二叉树节点 typedef struct TreeNode { char type; // 'V'(变量), 'C'(常量), 'O'(运算符) union { char var; // 变量名 int const_val; // 常数值 char op; // 运算符 } data; struct TreeNode *left; struct TreeNode *right; } TreeNode; // 全局变量表(a~z) int var_table[26] = {0}; // 初始值为0 // 运算符优先级 int get_priority(char op) { if (op == '+' || op == '-') return 1; if (op == '*' || op == '/') return 2; if (op == '^') return 3; return 0; } // 运算符结合性 (0:左结合,1:右结合) int get_assoc(char op) { return (op == '^') ? 1 : 0; // 指数^右结合,其它左结合 } // 创建节点函数 // 变量 TreeNode* create_var_node(char var) { TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode)); node->type = 'V'; node->data.var = var; node->left = node->right = NULL; return node; } // 常量 TreeNode* create_const_node(int val) { TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode)); node->type = 'C'; node->data.const_val = val; node->left = node->right = NULL; return node; } // 运算符 TreeNode* create_op_node(char op) { TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode)); node->type = 'O'; node->data.op = op; node->left = node->right = NULL; return node; } // 分割前缀表达式为tokens int split_tokens(const char* expr, char*** tokens) { char* expr_copy = strdup(expr); // 复制字符串 *tokens = (char**)malloc(100 * sizeof(char*)); int count = 0; char* token = strtok(expr_copy, " "); // 空格分割 while (token) { (*tokens)[count++] = strdup(token); token = strtok(NULL, " "); } free(expr_copy); return count; } // 前缀表达式构建二叉树 (从右向左扫描) TreeNode* build_expr_tree(char** tokens, int start, int end) { TreeNode* stack[100] = {0}; int top = -1; for (int i = end; i >= start; i--) { char* tok = tokens[i]; TreeNode* node = NULL; if (isalpha(tok[0])) { // 变量 node = create_var_node(tok[0]); } else if (isdigit(tok[0]) || (tok[0] == '-' && isdigit(tok[1]))) { // 常量(包含负数) node = create_const_node(atoi(tok)); } else { // 运算符 node = create_op_node(tok[0]); node->left = stack[top--]; // 弹出左操作数 node->right = stack[top--]; // 弹出右操作数 } stack[++top] = node; // 压栈 } return stack[0]; // 栈底即为根节点 } // 递归中序输出带括号的中缀表达式 void infix_print(TreeNode* node, int parent_pri, int is_right) { if (!node) return; int cur_pri = (node->type == 'O') ? get_priority(node->data.op) : 0; int need_paren = 0; if (node->type == 'V') { printf("%c", node->data.var); } else if (node->type == 'C') { printf("%d", node->data.const_val); } else { // 运算符 // 左子树处理 if (node->left) { int left_pri = (node->left->type == 'O') ? get_priority(node->left->data.op) : 0; need_paren = (cur_pri > left_pri) || (cur_pri == left_pri && !get_assoc(node->data.op)); if (need_paren) printf("("); infix_print(node->left, cur_pri, 0); if (need_paren) printf(")"); } // 输出运算符 printf(" %c ", node->data.op); // 右子树处理 if (node->right) { int right_pri = (node->right->type == 'O') ? get_priority(node->right->data.op) : 0; need_paren = (cur_pri > right_pri) || (cur_pri == right_pri && get_assoc(node->data.op)); if (need_paren) printf("("); infix_print(node->right, cur_pri, 1); if (need_paren) printf(")"); } } } // 变量赋值函数 void assign_var(char var, int value) { var_table[var - 'a'] = value; } // 表达式求值(后序遍历) double evaluate_expr(TreeNode* node) { if (!node) return 0; if (node->type == 'V') return var_table[node->data.var - 'a']; if (node->type == 'C') return node->data.const_val; double left = evaluate_expr(node->left); double right = evaluate_expr(node->right); switch (node->data.op) { case '+': return left + right; case '-': return left - right; case '*': return left * right; case '/': if (right == 0) { printf("Divide by zero!"); exit(1); } return left / right; case '^': return pow(left, right); default: return 0; } } // 构造复合表达式 TreeNode* compound_expr(char op, TreeNode* left_expr, TreeNode* right_expr) { TreeNode* root = create_op_node(op); root->left = left_expr; root->right = right_expr; return root; } // 释放表达式树内存 void free_tree(TreeNode* root) { if (!root) return; free_tree(root->left); free_tree(root->right); free(root); } // 新增函数:查找表达式中使用的变量 void find_used_vars(TreeNode* node, int* vars_used) { if (!node) return; if (node->type == 'V') { vars_used[node->data.var - 'a'] = 1; } find_used_vars(node->left, vars_used); find_used_vars(node->right, vars_used); } int main() { while (1) { // 持续处理表达式直到用户退出 char input[256]; printf("\n输入前缀表达式 (or 'exit' to quit): "); fgets(input, sizeof(input), stdin); input[strcspn(input, "\n")] = '\0'; // 处理退出条件 if (strcmp(input, "exit") == 0) break; if (strlen(input) == 0) continue; // 空输入处理 // 初始化变量表 for (int i = 0; i < 26; i++) var_table[i] = 0; // 分割tokens并构建树 char** tokens = NULL; int token_count = split_tokens(input, &tokens); TreeNode* root = build_expr_tree(tokens, 0, token_count - 1); if (!root) { printf("Expression tree construction failed.\n"); // 清理内存后继续 for (int i = 0; i < token_count; i++) free(tokens[i]); free(tokens); continue; } // 输出中缀表达式 printf("输出中缀表达式: "); infix_print(root, 0, 0); printf("\n"); // 识别并赋值变量 int vars_used[26] = {0}; find_used_vars(root, vars_used); // 变量赋值处理 int any_vars = 0; for (char var = 'a'; var <= 'z'; var++) { if (vars_used[var - 'a']) { any_vars = 1; int value; printf("对变量赋值 %c: ", var); scanf("%d", &value); assign_var(var, value); } } while (getchar() != '\n'); // 清除输入缓冲区 if (!any_vars) { printf("No variables to assign.\n"); } // 表达式求值 double result = evaluate_expr(root); printf("输出结果: %.2f\n", result); // 释放内存准备下一次输入 free_tree(root); for (int i = 0; i < token_count; i++) free(tokens[i]); free(tokens); } printf("Program exited.\n"); return 0; }简化一部分代码
最新发布
06-10
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值