「大数逆序java」奇数逆序数

今天给各位分享大数逆序java的知识，其中也会对奇数逆序数进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、［java］输入一个整型数组，然后求出该数组中最大的元素与最小的元素，最后逆序输出该数组。怎么编程
• 2、请给出java几种排序方法
• 3、JAVA面试中遇到的难题，跪求答案啊
• 4、java怎么让数组的数字从大到小排序？
• 5、java数组实现大数相加
• 6、运用JAVA中大数类实现大数的四则运算

［java］输入一个整型数组，然后求出该数组中最大的元素与最小的元素，最后逆序输出该数组。怎么编程

import java.util.Scanner;

public class Test {

public static void main (String[] args) {

Scanner scanner = new Scanner(System.in);

int count = 0;

int temp;

int max, min;

System.out.println("请输入数组的大小");

count = scanner.nextInt();

System.out.println("请输入数组：");

int[] numbers = new int[count];

for (int i = 0; i  count; i++)

numbers[i] = scanner.nextInt();

System.out.println("数组为：");

for (int i = 0; i  numbers.length; i++)

System.out.println(numbers[i]);

max = min = numbers[0];

for (int i = 0; i  numbers.length; i++) {

if (max  numbers[i]) {

max = numbers[i];

}

if (min  numbers[i]) {

min = numbers[i];

}

}

System.out.println("最大数为：" + max + "最小数为：" + min);

for (int i = 0; i  numbers.length / 2; i++) {

temp = numbers[i];

numbers[i] = numbers[count - 1 - i];

numbers[count - 1 - i] = temp;

}

System.out.println("数组逆序为：");

for (int i = 0; i  numbers.length; i++) {

System.out.println(numbers[i]);

}

}

}

请给出java几种排序方法

java常见的排序分为：

1 插入类排序

主要就是对于一个已经有序的序列中，插入一个新的记录。它包括：直接插入排序，折半插入排序和希尔排序

2 交换类排序

这类排序的核心就是每次比较都要“交换”，在每一趟排序都会两两发生一系列的“交换”排序，但是每一趟排序都会让一个记录排序到它的最终位置上。它包括：起泡排序，快速排序

3 选择类排序

每一趟排序都从一系列数据中选择一个最大或最小的记录，将它放置到第一个或最后一个为位置交换，只有在选择后才交换，比起交换类排序，减少了交换记录的时间。属于它的排序：简单选择排序，堆排序

4 归并类排序

将两个或两个以上的有序序列合并成一个新的序列

5 基数排序

主要基于多个关键字排序的。

下面针对上面所述的算法，讲解一些常用的java代码写的算法

二 插入类排序之直接插入排序

直接插入排序,一般对于已经有序的队列排序效果好。

基本思想：每趟将一个待排序的关键字按照大小插入到已经排序好的位置上。

算法思路，从后往前先找到要插入的位置，如果小于则就交换，将元素向后移动，将要插入数据插入该位置即可。时间复杂度为O(n2),空间复杂度为O(1)

package sort.algorithm;

public class DirectInsertSort {

public static void main(String[] args) {

// TODO Auto-generated method stub

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };

int temp, j;

for (int i = 1; i data.length; i++) {

temp = data[i];

j = i - 1;

// 每次比较都是对于已经有序的

while (j = 0 data[j] temp) {

data[j + 1] = data[j];

j--;

}

data[j + 1] = temp;

}

// 输出排序好的数据

for (int k = 0; k data.length; k++) {

System.out.print(data[k] + " ");

}

}

}

三 插入类排序之折半插入排序(二分法排序)

条件：在一个已经有序的队列中，插入一个新的元素

折半插入排序记录的比较次数与初始序列无关

思想：折半插入就是首先将队列中取最小位置low和最大位置high，然后算出中间位置mid

将中间位置mid与待插入的数据data进行比较，

如果mid大于data，则就表示插入的数据在mid的左边，high=mid-1;

如果mid小于data，则就表示插入的数据在mid的右边,low=mid+1

最后整体进行右移操作。

时间复杂度O(n2),空间复杂度O(1)

package sort.algorithm;

//折半插入排序

public class HalfInsertSort {

public static void main(String[] args) {

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };

// 存放临时要插入的元素数据

int temp;

int low, mid, high;

for (int i = 1; i data.length; i++) {

temp = data[i];

// 在待插入排序的序号之前进行折半插入

low = 0;

high = i - 1;

while (low = high) {

mid = (low + high) / 2;

if (temp data[mid])

high = mid - 1;

else

// low=high的时候也就是找到了要插入的位置，

// 此时进入循环中，将low加1，则就是要插入的位置了

low = mid + 1;

}

// 找到了要插入的位置，从该位置一直到插入数据的位置之间数据向后移动

for (int j = i; j = low + 1; j--)

data[j] = data[j - 1];

// low已经代表了要插入的位置了

data[low] = temp;

}

for (int k = 0; k data.length; k++) {

System.out.print(data[k] + " ");

}

}

}

四 插入类排序之希尔排序

希尔排序，也叫缩小增量排序，目的就是尽可能的减少交换次数，每一个组内最后都是有序的。

将待续按照某一种规则分为几个子序列，不断缩小规则，最后用一个直接插入排序合成

空间复杂度为O(1)，时间复杂度为O(nlog2n)

算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

package sort.algorithm;

public class ShellSort {

public static void main(String[] args) {

int a[] = { 1, 54, 6, 3, 78, 34, 12, 45, 56, 100 };

double d1 = a.length;

int temp = 0;

while (true)

{

//利用这个在将组内倍数减小

//这里依次为5,3,2,1

d1 = Math.ceil(d1 / 2);

//d为增量每个分组之间索引的增量

int d = (int) d1;

//每个分组内部排序

for (int x = 0; x d; x++)

{

//组内利用直接插入排序

for (int i = x + d; i a.length; i += d) {

int j = i - d;

temp = a[i];

for (; j = 0 temp a[j]; j -= d) {

a[j + d] = a[j];

}

a[j + d] = temp;

}

}

if (d == 1)

break;

}

for (int i = 0; i a.length; i++)

System.out.print(a[i]+" ");

}

}

五 交换类排序之冒泡排序

交换类排序核心就是每次比较都要进行交换

冒泡排序：是一种交换排序

每一趟比较相邻的元素，较若大小不同则就会发生交换，每一趟排序都能将一个元素放到它最终的位置！每一趟就进行比较。

时间复杂度O(n2)，空间复杂度O(1)

package sort.algorithm;

//冒泡排序：是一种交换排序

public class BubbleSort {

// 按照递增顺序排序

public static void main(String[] args) {

// TODO Auto-generated method stub

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20, 13, 100, 37, 16 };

int temp = 0;

// 排序的比较趟数,每一趟都会将剩余最大数放在最后面

for (int i = 0; i data.length - 1; i++) {

// 每一趟从开始进行比较，将该元素与其余的元素进行比较

for (int j = 0; j data.length - 1; j++) {

if (data[j] data[j + 1]) {

temp = data[j];

data[j] = data[j + 1];

data[j + 1] = temp;

}

}

}

for (int i = 0; i data.length; i++)

System.out.print(data[i] + " ");

}

}

JAVA面试中遇到的难题，跪求答案啊

1.第一个是建立一个输入流，将文件导入，然后按照将空格和标点换成统一的一个分隔符（自己定），然后分成一个包含若干个string数组的数组，最后用for查一下就知道了。

2.public long multi(long d1, long d2){

return di*d2;

}

回答补充：难道bigdicimal就能解决了？？要知道两个数的乘积可是几何倍的成长，如果是两个最大的bigdicimal相乘你要怎么算?肯定要溢出。无论怎么写都会溢出的。

除非将参数设置成字符串，然后自己写乘积算法。

我估计这道题的目的在于你是否意识到类型定义的问题

java怎么让数组的数字从大到小排序？

将数字从大到小排序的方法：

例如简一点的冒泡排序，将第一个数字和后面的数字逐个比较大小，如果小于，则互换位置，大于则不动。此时，第一个数为数组中的最大数。然后再将第二个数与后面的数逐个比较，以次类推。

示例代码如下： 

public class Test { 

public static void main(String[] args) { 

int [] array = {12,3,1254,235,435,236,25,34,23}; 

int temp; 

for (int i = 0; i  array.length; i++) { 

for (int j = i+1; j  array.length; j++) { 

if (array[i]  array[j]) { 

temp = array[i]; 

array[i] = array[j]; 

array[j] = temp; // 两个数交换位置 

} 

} 

} 

for (int i = 0; i  array.length; i++) { 

System.out.print(array[i]+"  "); 

} 

} 

}

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。

Java 语言中提供的数组是用来存储固定大小的同类型元素。

你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99

扩展资料

Java中利用数组进行数字排序一般有4种方法：

1、选择排序是先将数组中的第一个数作为最大或最小数，然后通过循环比较交换最大数或最小数与一轮比较中第一个数位置进行排序。

2、冒泡排序也是先将数组中的第一个数作为最大或最小数，循环比较相邻两个数的大小，满足条件就互换位置，将最大数或最小数沉底。

3、快速排序法主要是运用Arrays类中的Arrays.sort方法（）实现。

4、插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。

java数组实现大数相加

package com.nileader.big.entity;

public class BigInt {

private String data_str; //原始数据

private int digit; //数据位数

private int[] data; //大数

private boolean carry = false; //进位标识符

/**

* setter and getter

*/

public boolean isCarry() {

return carry;

}

public void setCarry(boolean carry) {

this.carry = carry;

}

public String getData_str() {

return data_str;

}

public void setData_str(String data_str) {

this.data_str = data_str;

}

public int[] getData() {

return data;

}

public void setData(int[] data) {

this.data = data;

}

public int getDigit() {

return digit;

}

public void setDigit(int digit) {

this.digit = digit;

}

//构造方法

public BigInt(){};

public BigInt(String str_data)

{

this.setData_str(str_data);

}

//基本操作

/**

* 形成大数 初始化

*/

public void initBInt()

{

this.setDigit( this.getData_str().length() );

this.data = new int[this.getDigit()];

//将字符组成的大数逆序放入int[] data中

for(int i = 0, j=this.getDigit() ; i

{

// 1104 -- data[0] = '4',data[1] = '0',data[2]=1, data[3]= '1'

this.data[i] = Integer.parseInt( this.getData_str().substring(j-1,j) );

}

}

/**

* 进行大数相加操作

*/

public void add( BigInt bint)

{

//this的位数大于bint的位数

if( this.getDigit() bint.getDigit() )

{

int[] datatemp = this.getData();

this.setData( bint.getData());

bint.setData( datatemp);

this.setDigit(this.getData().length);

bint.setDigit(bint.getData().length);

}

//将短的那个先加完

int i =0;

for(; i

{

int tdata = 0;

//上次运算有进位

if( this.isCarry())

{

tdata = this.getData()[i] + bint.getData()[i] +1;

//取消进位标识

this.setCarry(false);

}

else tdata = this.getData()[i] + bint.getData()[i] ;

//本次结果无进位

if(tdata 10) this.data[i] = tdata;

//本次结果有进位

else if(tdata =10)

{

this.data[i] = tdata -10;

this.setCarry(true);

}

} //短的那个加完了

//剩余数的处理

for(;i

{

//有个进位的

if(this.isCarry())

{

int tdata = this.data[i]+1;

if(tdata =10) this.data[i] = tdata -10;

else

{

this.data[i] = tdata;

this.setCarry(false);

}

}

}

//对最高位益处检测

if(this.data[this.getDigit()-1] == 0)

{

int[] tdata = new int[this.getDigit()+1];

System.arraycopy(this.getData(), 0, tdata, 0, this.getDigit());

tdata[this.getDigit()] = 1;

this.setData(tdata);

}

}

}

其中代码段

//对最高位益处检测

if(this.data[this.getDigit()-1] == 0)

{

int[] tdata = new int[this.getDigit()+1];

System.arraycopy(this.getData(), 0, tdata, 0, this.getDigit());

tdata[this.getDigit()] = 1;

this.setData(tdata);

}

运用JAVA中大数类实现大数的四则运算

import java.math.BigInteger;

public class BigIntegerGet {

public String getAdd(String Str1,String Str2){

String Str3=new String();

BigInteger BigInt1=new BigInteger(Str1);

BigInteger BigInt2=new BigInteger(Str2);

BigInt1=BigInt1.add(BigInt2);

Str3=BigInt1.toString();

return Str3;

}

public String getSubtract(String Str1,String Str2){

String Str3=new String();

BigInteger BigInt1=new BigInteger(Str1);

BigInteger BigInt2=new BigInteger(Str2);

BigInt1=BigInt1.subtract(BigInt2);

Str3=BigInt1.toString();

return Str3;

}

public String getMultiply(String Str1,String Str2){

String Str3=new String();

BigInteger BigInt1=new BigInteger(Str1);

BigInteger BigInt2=new BigInteger(Str2);

BigInt1=BigInt1.multiply(BigInt2);

Str3=BigInt1.toString();

return Str3;

}

public String getDivide(String Str1,String Str2){

String Str3=new String();

BigInteger BigInt1=new BigInteger(Str1);

BigInteger BigInt2=new BigInteger(Str2);

BigInt1=BigInt1.divide(BigInt2);

Str3=BigInt1.toString();

return Str3;

}

}

大数逆序java的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于奇数逆序数、大数逆序java的信息别忘了在本站进行查找喔。