数组逆序关键是 b[i]=a[a.length-1-i]

最新推荐文章于 2022-02-25 20:51:13 发布
原创 最新推荐文章于 2022-02-25 20:51:13 发布 · 1.3k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文提供了一个简单的Java程序示例，展示了如何通过创建一个名为Numbers的公共类及其静态方法来实现一维整数数组的反转。该程序首先初始化了一个包含10个元素的数组，并按升序填充了这些元素。接着，通过遍历原始数组并将其元素逆序赋值到新数组中实现了数组的反转。此外，还提供了一个用于打印数组内容的方法。
public class Numbers{

public  static void main(String args[]){


    int oldArr[]=new int[10];
    int newArr[]=new int[10];
   
    for(int i=0;i<oldArr.length;i++){
    oldArr[i]=i;
    }
    print(oldArr);
    //System.out.println(oldArr[i]);
    for(int i=0;i<oldArr.length;i++){
    newArr[i]=oldArr[oldArr.length-1-i];
   
    }
    print(newArr);
    }
public static void print(int temp[]){
for (int i=0;i<temp.length;i++){
System.out.println("数组是 "+temp[i]);
}
System.out.println("\n");
}
   
    }
   
    
    
    
    





c_c123
关注
C#基础 冒泡排序 二层循环长度： array.Length - 1 - i
yhx956058885的博客
09-16 472
冒泡排序 小数放前面，大数放后面 void BubbleSort(int[] array) { for (int i = 0; i < array.Length - 1; i++) { for (int j = 0; j < array.Length - 1 - i; j++) { if (array[j] > array[j + 1])
数组中的逆序对
reigns的博客
10-23 150
题目描述 在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007 输入描述: 题目保证输入的数组中没有的相同的数字 数据范围： 对于%50的数据,size<=10^4 对于%75的数据,size<=10^5 对于%1...
给定一个数组A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1],其中B中的元素B[i]=A[0]*A[1]*...*A[i-1]*A[i+1]*...*A[n-1]
波波诸葛伟
11-30 989
2017年09月05日 09:28:18 冰镇-西瓜 阅读数：733更多 个人分类： 剑指Offer 版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/hhgggggg/article/details/77847528 问：给定一个数组A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1],其中B中的元素B[i]=A[0]*...
《十大排序算法》文章集锦
程序员之道
11-27 237
术语说明： 稳定 ：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定 ：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面。 内排序 ：所有排序操作都在内存中完成。 外排序 ：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行。 时间复杂度 ：耗费的时间。 空间复杂度 ：所需内存的大小。 排序方法 平均时间复杂度 时间复杂度（最好情况） 时间复杂度（最坏情况） 空间复杂度 稳定性 冒泡排序 O(n2)O(n^2)O(n2) O(n)O(
JavaScript 数组
小东西@不许怪我霸道的博客
10-27 253
数组
//定义一个数组，再逆序存储它的值 //int[] a = new int[] { 21, 12, 9, 14, 17, 7 }; //经过一系列操作后将数组变成： { 7,17,14,9,12,21} int[] a3 = new int[] { 54, 46, 34, 23, 12, 9, 7, 6, 3, 1 }; for (int i = 0; i < a3.Length; i++) { a3[i] = i; } int[] a4 = new int[a3.Length]; for (int i = 0; i < a3.Length; i++) { a4[i] = a3[a3.Length - 1 - i]; } for (int i = 0; i < a3.Length ; i++) { Console.Write( a3[i]+","); }
最新发布
11-28
选项1（使用原数组逆序，不创建新数组）： // 先将a3填充为0,1,2,...（题目中给出的循环） for (int i = 0; i < a3.Length; i++) { a3[i] = i; } // 然后对a3进行逆序（使用双指针交换） int left = 0; ...
#include <stdio.h> #include <string.h> #include <stdbool.h> #define MAX_DIGITS 100 // 大整数结构体 typedef struct { int digits[MAX_DIGITS]; // 存储各位数字，digits[0]是个位 int length; // 数字的长度 bool isNegative; // 是否为负数 } BigInt; // 初始化大整数 void initBigInt(BigInt *num) { memset(num->digits, 0, sizeof(num->digits)); num->length = 0; num->isNegative = false; } // 函数声明 BigInt addBigInt(const BigInt *a, const BigInt *b); BigInt subBigInt(const BigInt *a, const BigInt *b); BigInt mulBigInt(const BigInt *a, const BigInt *b); BigInt divBigInt(const BigInt *a, const BigInt *b, BigInt *remainder); // 从字符串初始化大整数 void initBigIntFromString(BigInt *num, const char *str) { initBigInt(num); int len = strlen(str); int start = 0; // 处理负数 if (str[0] == '-') { num->isNegative = true; start = 1; } // 从字符串末尾开始读取数字 int i = len - 1; for (i = len - 1; i >= start; i--) { if (str[i] >= '0' && str[i] <= '9') { num->digits[num->length++] = str[i] - '0'; } } // 去除前导零 while (num->length > 1 && num->digits[num->length - 1] == 0) { num->length--; } // 处理0的情况 if (num->length == 1 && num->digits[0] == 0) { num->isNegative = false; } } // 比较两个大整数的绝对值大小 // 返回1表示a > b，0表示a == b，-1表示a < b int compareAbsolute(const BigInt *a, const BigInt *b) { if (a->length > b->length) return 1; if (a->length < b->length) return -1; int i = a->length - 1; for (i = a->length - 1; i >= 0; i--) { if (a->digits[i] > b->digits[i]) return 1; if (a->digits[i] < b->digits[i]) return -1; } return 0; } // 比较两个大整数的大小 // 返回1表示a > b，0表示a == b，-1表示a < b int compareBigInt(const BigInt *a, const BigInt *b) { // 符号不同 if (a->isNegative && !b->isNegative) return -1; if (!a->isNegative && b->isNegative) return 1; // 都是正数 if (!a->isNegative && !b->isNegative) { return compareAbsolute(a, b); } // 都是负数 else { return -compareAbsolute(a, b); } } // 大整数加法 BigInt addBigInt(const BigInt *a, const BigInt *b) { BigInt result; initBigInt(&result); // 处理符号不同的情况，转换为减法 if (a->isNegative != b->isNegative) { if (a->isNegative) { BigInt temp = *a; temp.isNegative = false; result = subBigInt(b, &temp); } else { BigInt temp = *b; temp.isNegative = false; result = subBigInt(a, &temp); } return result; } result.isNegative = a->isNegative; int carry = 0; int maxLength = (a->length > b->length) ? a->length : b->length; int i = 0; for (i = 0; i < maxLength; i++) { int sum = a->digits[i] + b->digits[i] + carry; result.digits[result.length++] = sum % 10; carry = sum / 10; } if (carry > 0) { result.digits[result.length++] = carry; } return result; } // 大整数减法（假设a的绝对值大于等于b的绝对值） BigInt subAbsolute(const BigInt *a, const BigInt *b) { BigInt result; initBigInt(&result); int borrow = 0; int i = 0; for (i = 0; i < a->length; i++) { int diff = a->digits[i] - borrow; if (i < b->length) { diff -= b->digits[i]; } if (diff < 0) { diff += 10; borrow = 1; } else { borrow = 0; } result.digits[result.length++] = diff; } // 去除前导零 while (result.length > 1 && result.digits[result.length - 1] == 0) { result.length--; } return result; } // 大整数减法 BigInt subBigInt(const BigInt *a, const BigInt *b) { BigInt result; initBigInt(&result); // 处理符号不同的情况，转换为加法 if (a->isNegative != b->isNegative) { BigInt temp = *b; temp.isNegative = a->isNegative; result = addBigInt(a, &temp); return result; } // 比较绝对值大小 int cmp = compareAbsolute(a, b); if (cmp == 0) { // 绝对值相等，结果为0 result.digits[result.length++] = 0; return result; } if (cmp > 0) { // a的绝对值大于b的绝对值 result = subAbsolute(a, b); result.isNegative = a->isNegative; } else { // b的绝对值大于a的绝对值 result = subAbsolute(b, a); result.isNegative = !a->isNegative; } return result; } // 大整数乘法 BigInt mulBigInt(const BigInt *a, const BigInt *b) { BigInt result; initBigInt(&result); result.isNegative = a->isNegative != b->isNegative; // 处理乘数为0的情况 if ((a->length == 1 && a->digits[0] == 0) || (b->length == 1 && b->digits[0] == 0)) { result.digits[result.length++] = 0; result.isNegative = false; return result; } // 模拟竖式乘法 int i = 0; int j = 0; for (i = 0; i < a->length; i++) { for (j = 0; j < b->length; j++) { int product = a->digits[i] * b->digits[j]; int pos = i + j; // 累加到对应位置 result.digits[pos] += product; // 处理进位 if (result.digits[pos] >= 10) { result.digits[pos + 1] += result.digits[pos] / 10; result.digits[pos] %= 10; } } } // 确定结果长度 result.length = a->length + b->length; while (result.length > 1 && result.digits[result.length - 1] == 0) { result.length--; } return result; } // 大整数左移（乘以10的n次方） void leftShift(BigInt *num, int shift) { if (num->length == 1 && num->digits[0] == 0) { return; } int i = num->length - 1; for (i = num->length - 1; i >= 0; i--) { num->digits[i + shift] = num->digits[i]; } for (i = 0; i < shift; i++) { num->digits[i] = 0; } num->length += shift; } // 大整数右移（除以10的n次方） void rightShift(BigInt *num, int shift) { if (shift >= num->length) { num->digits[0] = 0; num->length = 1; return; } int i = 0; for (i = 0; i < num->length - shift; i++) { num->digits[i] = num->digits[i + shift]; } num->length -= shift; if (num->length == 0) { num->digits[0] = 0; num->length = 1; } } // 大整数除法 BigInt divBigInt(const BigInt *a, const BigInt *b, BigInt *remainder) { BigInt quotient; initBigInt(&quotient); // 处理除数为0的情况 if (b->length == 1 && b->digits[0] == 0) { printf("Error: Division by zero\n"); quotient.digits[quotient.length++] = 0; return quotient; } // 处理被除数为0的情况 if (a->length == 1 && a->digits[0] == 0) { quotient.digits[quotient.length++] = 0; initBigInt(remainder); remainder->digits[remainder->length++] = 0; return quotient; } quotient.isNegative = a->isNegative != b->isNegative; BigInt dividend; initBigInt(&dividend); memcpy(&dividend, a, sizeof(BigInt)); dividend.isNegative = false; BigInt divisor; initBigInt(&divisor); memcpy(&divisor, b, sizeof(BigInt)); divisor.isNegative = false; int cmp = compareAbsolute(&dividend, &divisor); if (cmp < 0) { // 被除数小于除数，商为0，余数为被除数 quotient.digits[quotient.length++] = 0; quotient.isNegative = false; memcpy(remainder, a, sizeof(BigInt)); return quotient; } else if (cmp == 0) { // 被除数等于除数，商为1或-1，余数为0 quotient.digits[quotient.length++] = 1; initBigInt(remainder); remainder->digits[remainder->length++] = 0; return quotient; } // 确定商的位数 int shift = dividend.length - divisor.length; leftShift(&divisor, shift); quotient.length = shift + 1; int i = shift; for (i = shift; i >= 0; i--) { while (compareAbsolute(&dividend, &divisor) >= 0) { // 执行减法 BigInt temp = subAbsolute(&dividend, &divisor); memcpy(&dividend, &temp, sizeof(BigInt)); quotient.digits[i]++; } // 除数右移一位 rightShift(&divisor, 1); } // 去除商的前导零 while (quotient.length > 1 && quotient.digits[quotient.length - 1] == 0) { quotient.length--; } // 设置余数 memcpy(remainder, &dividend, sizeof(BigInt)); remainder->isNegative = a->isNegative; // 余数为0时符号为正 if (remainder->length == 1 && remainder->digits[0] == 0) { remainder->isNegative = false; } return quotient; } // 打印大整数 void printBigInt(const BigInt *num) { if (num->isNegative) { printf("-"); } int i = num->length - 1; for (i = num->length - 1; i >= 0; i--) { printf("%d", num->digits[i]); } } int main() { char str1[MAX_DIGITS + 2]; // +2 for sign and null terminator char str2[MAX_DIGITS + 2]; printf("Enter first big integer: "); scanf("%s", str1); printf("Enter second big integer: "); scanf("%s", str2); BigInt a, b; initBigIntFromString(&a, str1); initBigIntFromString(&b, str2); printf("\nA = "); printBigInt(&a); printf("\nB = "); printBigInt(&b); printf("\n"); // 加法 BigInt sum = addBigInt(&a, &b); printf("\nA + B = "); printBigInt(&sum); // 减法 BigInt diff = subBigInt(&a, &b); printf("\nA - B = "); printBigInt(&diff); // 乘法 BigInt product = mulBigInt(&a, &b); printf("\nA * B = "); printBigInt(&product); // 除法 if (!(b.length == 1 && b.digits[0] == 0)) { BigInt remainder; BigInt quotient = divBigInt(&a, &b, &remainder); printf("\nA / B = "); printBigInt(&quotient); printf(" ... "); printBigInt(&remainder); } else { printf("\nCannot divide by zero"); } printf("\n"); return 0; }好了，这是我最终要用的代码，我是一个C语言零基础的人，请详细的为我讲解这段代码，以便我应付我刁钻的老师，帮助我顺利通过答辩。首先我想问为何要比较两个大整数的绝对值大小，
06-25
1. **从高位开始比较**：通过 `i = a->length - 1` 初始化变量 `i` 指向最高位。 2. **按位比较**：在每次迭代中，比较当前位 `a->digits[i]` 和 `b->digits[i]`。 - 如果 `a` 当前位更大，则直接返回 `1`，表示 `a...
}\nvoid divide(string s1,string s2){\n\ta[0]=s1.length();//用a[0]存储它的长度 \n\tb[0]=s2.length();\n\tfor(int i=0;i\u003Cs1.length();i++){\n\t\ta[s1.length()-i]=s1[i]-'0';//逆序存储 \n\t}\n\tfor(int i=0;i\u003Cs2.length();i++){\n\t\tb[s2.length()-i]=s2[i]-'0';\n\t}\n\tint lc=s1.length()-s2.length()+1;\n\tfor(int i=lc;i>=1;i--){\n\t\tmemset(temp,0,sizeof(temp));\n\t\tmove(b,temp,i-1);//将除数左移i
03-31
比如，s1的第i个字符被转换为数字后，存储在a数组的s1.length()-i的位置，这样原来的最高位在字符串的最左边，在数组a中会被存在最后的位置，所以整体是逆序存储的，这样处理可能是为了方便后续的运算，比如加减乘除...
请帮我用C++ 代码执行;给你一个下标从 0 开始的整数数组 nums 。对于每个下标 i（1 <= i <= nums.length - 2），nums[i] 的 美丽值 等于： 2，对于所有 0 <= j < i 且 i < k <= nums.length - 1 ，满足 nums[j] < nums[i] < nums[k] 1，如果满足 nums[i - 1] < nums[i] < nums[i + 1] ，且不满足前面的条件 0，如果上述条件全部不满足 返回符合 1 <= i <= nums.length - 2 的所有 nums[i] 的 美丽值的总和 。 示例 1： 输入：nums = [1,2,3] 输出：2 解释：对于每个符合范围 1 <= i <= 1 的下标 i : - nums[1] 的美丽值等于 2 示例 2： 输入：nums = [2,4,6,4] 输出：1 解释：对于每个符合范围 1 <= i <= 2 的下标 i : - nums[1] 的美丽值等于 1 - nums[2] 的美丽值等于 0 示例 3： 输入：nums = [3,2,1] 输出：0 解释：对于每个符合范围 1 <= i <= 1 的下标 i : - nums[1] 的美丽值等于 0 提示： 3 <= nums.length <= 105 1 <= nums[i] <= 105
03-12
例如，对于每个元素num，检查是否存在两个不同的元素a和b，使得a + b = num。这种情况下，对于每个元素，需要遍历所有可能的两个数的组合，导致时间复杂度为O(n^3)，但可以通过使用哈希表优化到O(n^2)。 但根据用户...
reverseLine() { if (this.curSelect == null || store.state.curJson == null) { return; } console.log(66666, store.state.curJson); const linearType = store.state.curJson.linear_object_type; let lineId = store.state.curJson.id; let group = this.curSelect; let items = group.children; for (let j = items.length - 1; j >= 0; j--) { let item = items[j]; if (item?.combType === "ArrowHelper") { group.remove(item); item.dispose(); } } this.reverseMarkingType(store.state.curJson); this.reverseSubMarkingType(store.state.curJson); if (store.state.curJson.seg_point) { let seg_point = store.state.curJson.seg_point; for (let i = 0; i < seg_point.length; i++) { let seg = seg_point[i]; if (seg) { this.reverseMarkingType(seg); if (seg.seg_points_id?.length > 0) { seg.seg_points_id = seg.seg_points_id.reverse(); } } } } let point = store.state.curJson.point; let pLength = point.length / 4; let pointsJsonArr = []; for (let j = pLength - 1; j >= 0; j--) { pointsJsonArr.push( point[j * 4], point[j * 4 + 1], point[j * 4 + 2], point[j * 4 + 3], ); } const len = group.children.length; for (let i = len - 1; i >= 0; --i) { group.children.push(group.children[i]); } group.children.splice(0, len); this.createArrowHeader(pointsJsonArr, group, lineId, 1, "#ff0000"); store.state.curJson.point.splice( 0, pointsJsonArr.length, ...pointsJsonArr, ); eventGlobal.trigger("showElements"); //触发映射更新 } 分析一下，再反转线段时做了哪些事
10-30
比如原来是从 A→B→C，现在变成 C→B→A。 --- ```js let point = store.state.curJson.point; let pLength = point.length / 4; let pointsJsonArr = []; for (let j = pLength - 1; j >= 0; j--) { ...
求数组中的最大值，并找出最大值在数组中的位置——java——一维数组与二维数组
hey，欢迎浏览我的博客，希望能给你提供帮助。
03-17 7318
package package2; public class ShuZuZuiDaZhiJiQiWeiZhi { public static void main(String[] args) { int []b= {1,2,3,4,5,6,7,8}; System.out.println("b数组中的内容为:"); for(int i=0;i<b.length;i+...
Java练习23：递归求数组a[]中最小值
qq_51165184的博客
10-10 1204
1.明确要干嘛：求数组a[]中最小值 2.递归结束条件： x=a.length-1；//扫描到数组中最后一个数 3.缩小参数范围： a[x]——>a[x-1]——>a[x-2]——>……——>a[0] 找到等价的关系式： Math.min(a[x], min(a,x+1)) 以a[3]为例 k=min(a,0) 0≠2，min(a[0],min(a,1)) 1≠2，min(a,1))=>min(a[1],min(a,2)) 2=2，min(a[1],..
java基础（6）java数组常用算法
weixin_42496678的博客
07-19 1106
一、选择排序（升序） 原理：选择一个位置（一般拿数组的第一个元素），拿这个位置上的值不断和其他位置的值进行比较。 将最小的元素交换至左侧，每一轮比较的次数，比上一轮少一次   class Demo_Selection_Sort  {     public static void main(String[] args)      {         /*             已知一个...
学习笔记（三）
l1198158939的博客
02-25 262
集合 用来存放一组数据的数据结构 数组 属于object类，用来存放一组数据的数据结构，数组是最基本的一种数据结构但不是基本数据类型，数组是相同数据类型组成的集合，数组中的元素按线性顺序排序 数组的长度属性 a.length 数组一旦创立，长度不可变 最大下标 a.length-1 允许0长度的数组 数组的缺点： 长度固定 ; 访问方式单一只能下标访问; 前面增删数据操作繁琐 Arrays 数组工具类 Arrays.toString（数组） 把数组数据连接成字符串。 Arrays.so
Java基础之数组
qq_51875488的博客
10-07 187
数组 1.定义 数组是相同类型数据的有序集合 数组描述的是相同类型的若干个数据，按照一定的先后顺序排列组合而成 每一个数据称作为一个数组元素，通过下标（索引）访问（下标从0开始） 2.创建方式 一般分为静态初始化和动态初始化 动态初始化（可改变值）：int[] arr = new int[5]; 静态初始化（定义后不可改变）：int[] arr = {1,2,3,4,5}; //静态初始化 int[] arr = new int[]{1,2,3,4,5}; public class ArrayDemo
Java数组中a.length的应用
weixin_62416697的博客
12-09 5414
package chap04; public class ExampleLength { public static void main(String[] args){ //int []a = {1, 2, 3, 4,}; //一维数组 int [][]a={{1,2},{2,3,4},{5,6,7,8}}; // 二维数组 int []b = {100, 200, 300}; System.out.p.
冒泡排序
weixin_45519487的博客
06-12 229
1.冒泡排序的概念 冒泡排序的基本思想：通过对待排序序列从前向后（从下表较小的元素开始），依次比较相邻元素的值，若发现逆序就交 换，使值较大的元素逐渐从前移向后部。 优化： 因为在排序的过程中，各个元素都不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此在排序 过程中，设置一个标志flag判断元素是够进行过排序，从而减少不必要的比较。 2. 冒泡排序图解 如上图所示： ...
python冒泡排序原理_详解python算法之冒泡排序
weixin_39790510的博客
11-20 430
python之冒泡排序概念: 重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。算法原理冒泡排序算...
P1308 统计单词数 AC于2017.10.27 https://www.luogu.org/problemnew/show/P1308
流年成沙的成长史
07-29 557
题目描述 一般的文本编辑器都有查找单词的功能，该功能可以快速定位特定单词在文章中的位置，有的还能统计出特定单词在文章中出现的次数。 现在，请你编程实现这一功能，具体要求是：给定一个单词，请你输出它在给定的文章中出现的次数和第一次出现的位置。注意：匹配单词时，不区分大小写，但要求完全匹配，即给定单词必须与文章 中的某一独立单词在不区分大小写的情况下完全相同（参见样例1 ），如果给定单词仅是文章...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值