精华内容
下载资源
问答
  • 所以我有一个2D矩阵,我试图打印出从大到小的值.我基本上都是通过寻找最大值来做到这一点,当我找到它时,我在adjacencyMatrix中将该位置设置为1,这样我们就不再计算它了.问题是当我通过打印出最大的代码然后跳过第二大...

    所以我有一个2D矩阵,我试图打印出从大到小的值.我基本上都是通过寻找最大值来做到这一点,当我找到它时,我在adjacencyMatrix中将该位置设置为1,这样我们就不再计算它了.问题是当我通过打印出最大的代码然后跳过第二大代码来测试它正确启动的代码.然后找到了第3和第4大.跳过了一些,然后最终开始打印出0.

    这是我的代码:

    public static void findLongestPath(int rows, int columns, int[][] elevationMatrix, int[][] adjacencyMatrix)

    {

    int max = 0;

    for (int x = 0; x < rows * columns; x++)

    {

    for (int i = 0; i < rows; i++)

    {

    for (int j = 0; j < columns; j++)

    {

    if (elevationMatrix[i][j] > max && adjacencyMatrix[i][j] == 0)

    {

    max = elevationMatrix[i][j];

    adjacencyMatrix[i][j] = 1;

    }

    }

    }

    System.out.println(max);

    max = 0;

    }

    }

    我已经盯着它看了一会儿,找不到这个虫子,所以我觉得另一双眼睛可能有所帮助.

    附:拜托,请不要告诉我对阵列进行排序,因为我可以这样做.我需要维护原始数组的顺序.

    最佳答案

    public static void findLongestPath(int rows, int columns, int[][] elevationMatrix, int[][] adjacencyMatrix)

    {

    int max = 0;

    int cX, cY;

    for (int x = 0; x < rows * columns; x++)

    {

    for (int i = 0; i < rows; i++)

    {

    for (int j = 0; j < columns; j++)

    {

    if (elevationMatrix[i][j] > max && adjacencyMatrix[i][j] == 0)

    {

    max = elevationMatrix[i][j]; // possible max, xth iteration

    cX = i; // store i

    cY = j; // store j

    }

    }

    }

    System.out.println(max); // global max, xth iteration

    max = 0;

    // cX and cJ now point to coordinates of global max

    // all the possible max value coordinates are ignored.

    adjacencyMatrix[cX][cJ] = 1;

    }

    }

    在您找到整个矩阵中的最大数字(全局最大值)之后,我认为您需要设置adjacencyMatrix [] [] = 1,而不是找到最大值(可能的最大值).

    可以有更有效的方法来实现这一点,我指出在这种方法中需要做些什么才能工作.

    展开全文
  • import java.util.*;import java.io.*;import java.util.Arrays;import java.util.Collections;import org.apache.commons.lang3.ArrayUtils;@SuppressWarnings("unused")public class Tester {public static void m...

    import java.util.*;

    import java.io.*;

    import java.util.Arrays;

    import java.util.Collections;

    import org.apache.commons.lang3.ArrayUtils;

    @SuppressWarnings("unused")

    public class Tester {

    public static void main(String args[]){

    int i[] = {-7, 15, 21, 22, 43, 49, 51, 67, 81, 84, 89, 95, 97};

    ArrayUtils.reverse(i);

    System.out.println(binarySearch(i, 22));

    System.out.println(binarySearch(i, 89));

    System.out.println(binarySearch(i, -100));

    System.out.println(binarySearch(i, 72));

    System.out.println(binarySearch(i, 102));

    }

    private static int binarySearch(int a[], int srchVal){

    int lb = 0;

    int ub = a.length - 1;

    while(lb <= ub){

    int mid = (lb + ub)/2;

    if(a[mid] == srchVal){

    return mid;

    }

    else if(srchVal > a[mid]){

    lb = mid + 1;

    }

    else{

    ub = mid - 1;

    }

    }

    return -1;

    }

    }

    对于类中的分配,我需要修改BinarySearch方法,以便它与反向数组一起正常工作.但是我不知道该如何修改它.

    解决方法:

    如果数组按降序排序,则如果您颠倒了搜索算法执行的所有值比较的意义,则二进制搜索仍然可以工作.

    等于情况仍然可以,但是您可以将else if中的比较结果反转为<. else if>条件.

    标签:binary-search,java,sorting

    来源: https://codeday.me/bug/20191120/2046553.html

    展开全文
  • 1.Java数组的语法:String[数组下标], Java数组的下标是从0开始的。2.示例代码public class StringArray{public static void main(String[]args){//java数组初始化String[] strArray={"1","2","3"};//输出j...

    Java数组是在Java编程中经常使用的一个类,下面是对Java数组的使用说明。

    1.Java数组的语法: String[数组下标], Java数组的下标是从0开始的。

    2.示例代码

    public class StringArray

    {

    public static void main(String[]args)

    {

    //java数组初始化

    String[] strArray={"1","2","3"};

    //输出java数组

    for(int i=0;i

    {

    System.out.println(strArray[i]);//输出结果 1 2 3

    }

    //修改java数组的第二个元素为 a

    strArray[1]="a";

    //Java数组的长度

    int arrayLength=strArray.length;

    //   输出java数组

    for(int i=0;i

    {

    System.out.println(strArray[i]);//输出结果 1 a 3

    }

    }

    }

    输出如下:

    1

    2

    3

    1

    a

    3

    展开全文
  • Java数组数组概述数组的定义数组是相同类型数据的有序集合每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。数组声明和创建声明数组变量的语法dataType[] arrayRefaVar;//首选dataType ...

    Java数组

    数组概述

    数组的定义

    数组是相同类型数据的有序集合

    每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。

    数组声明和创建

    声明数组变量的语法

    dataType[] arrayRefaVar;//首选

    dataType arrayRefaVar[];

    用new操作符来创建数组的语法

    dataType[] arrayRefaVar = new dataType[arraySize];

    获取数组长度

    array.length

    56381c5565b3f334853ab25fcf57eec5.png

    数组的创建实例

    package com.kikikikikiku.array;

    public class ArrayDemo01 {

    public static void main(String[] args) {

    int sum=0;

    //1.声明一个数组

    int[] nums;

    //2.创建一个数组

    nums = new int[10];//这里面可以放10个int类型的数字

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

    //3.给数组元素赋值

    for (int i = 0; i

    nums[i]=i+1;

    sum += nums[i];

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

    if (i==nums.length-1){

    System.out.println();

    }

    }

    //计算所有元素的和

    System.out.println("所有元素的和为:"+sum);

    }

    }

    数组的三种初始化

    静态初始化

    int[] a ={1,2,3};

    Man[] mans = {new Man(1,1),new Man(2,2)};

    动态初始化

    int[] a = new int[2];

    a[0]=1;

    a[1]=2;

    默认初始化

    数组是引用类型,他的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也被按照实例变量同样的方式被隐式初始化。

    三种初始化代码:

    package com.kikikikikiku.array;

    import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

    public class ArrayDemo02 {

    public static void main(String[] args) {

    //静态初始化:创建+赋值

    int[] a = {1,2,3,4,5,6,7,8};

    System.out.println(a[0]);

    //动态初始化:包含默认初始化

    int[] b = new int[10];

    b[0] = 10;

    b[1] = 10;

    System.out.println(b[0]);

    System.out.println(b[1]);

    System.out.println(b[2]);

    }

    }

    内存分析

    cc1a49f0d278f9c1b0b86df878e12b43.png

    a9bdadaa9040d40c8dc66507ad250059.png

    数组的四个基本特点

    其长度是确定的。数组一旦被创建,它的大小就是不能改变的。

    其中的元素必须是相同类型,不允许出现混合类型。

    数组中的元素可以是任何数据类型,包括基本类型和引用类型。

    数组变量属于引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身即是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

    数组边界

    下标合法区间:[0,length-1],如果越界就会报错;

    package com.kikikikikiku.array;

    public class ArrayDemo03 {

    public static void main(String[] args) {

    int[] a= new int[2];

    System.out.println(a[2]);

    }

    }

    ArrayIndexOutOfBoundsException:数组下标越界异常!

    数组的使用

    普通的For循环

    for-each循环

    数组作方法入参

    数组作返回值

    数组元素的和以及数组最大元素

    package com.kikikikikiku.array;

    public class ArrayDemo04 {

    public static void main(String[] args) {

    int[] array={1,2,3,4,5};

    int sum =0;

    int max = array[0];

    //计算所有元素的和

    for (int i = 0; i

    sum+=array[i];

    }

    System.out.println(sum);

    //查找最大元素

    for (int i = 0; i

    if(max

    max = array[i];

    }

    System.out.println(max);

    }

    }

    反转数组

    package com.kikikikikiku.array;

    public class ArrayDemo05 {

    public static void main(String[] args) {

    int[] arrays = {1,2,3,4,5};

    int[] reverse = reverse(arrays);

    printArray(reverse);

    }

    //反转数组

    public static int[] reverse(int[] arrays){

    int[] result = new int[arrays.length];

    //反转的操作

    for (int i = 0,j=result.length-1; i

    result[j] = arrays[i];

    }

    return result;

    }

    //打印数组元素

    public static void printArray(int[] arrays){

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

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

    }

    }

    }

    多维数组

    多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组。

    二维数组

    语法:

    int a[][] = new int[2][5];

    c87bc7364b66b38852b10bb1f27f898d.png

    package com.kikikikikiku.array;

    public class ArrayDemo06 {

    public static void main(String[] args) {

    //[4][2]

    /*

    1,2 array[0]

    2,3 array[1]

    3,4 array[2]

    4,5 array[3]

    */

    int[][] array = {{1,2},{2,3},{3,4},{4,5}};

    // System.out.println(array[0]); //[I@1b6d3586

    // printArray(array[0]);//1 2

    //打印二维数组

    for (int i = 0; i

    for (int j = 0; j

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

    }

    System.out.println();

    }

    }

    public static void printArray(int[] arrays){

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

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

    }

    }

    }

    Arrays类

    数组的工具类java.util.Arrays

    具有以下常用功能:

    给数组赋值:通过fill方法

    对数组排序:通过sort方法,按升序。

    比较数组:通过equals方法比较数组中元素值是否相等。

    查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。

    Arrays.toString() & Arrays.sort()

    package com.kikikikikiku.array;

    import java.util.Arrays;

    public class ArrayDemo07 {

    public static void main(String[] args) {

    int[] a = {3324,4234241,1,4432,324,42};

    System.out.println(a);//[I@1b6d3586

    System.out.println(Arrays.toString(a));//打印数组

    // printArray(a);//打印数组

    System.out.println("=======================");

    Arrays.sort(a);//对数组进行排序

    System.out.println(Arrays.toString(a));

    System.out.println("=======================");

    // Arrays.fill(a,0);//数组填充

    // System.out.println(Arrays.toString(a));

    Arrays.fill(a,2,4,0);//a[2]到a[4]之间左闭右开填充0

    System.out.println(Arrays.toString(a));

    }

    //打印数组方法

    public static void printArray(int[] a){

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

    if (i==0){

    System.out.print("[");

    }

    if(i==a.length-1){

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

    }else{

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

    }

    }

    }

    }

    冒泡排序

    冒泡排序

    比较数组中,两个相邻的元素,如果第一个数比第二个数大,我们就交换它们的位置。

    每一次比较都会产生出一个最大或者最小的数

    下一轮就可以少一次排序

    依次循环直到结束

    package com.kikikikikiku.array;

    import java.util.Arrays;

    public class ArrayDemo08 {

    public static void main(String[] args) {

    int[] a={1,34,5,6,3,563,4532,43};

    System.out.println(Arrays.toString(sort(a)));

    }

    public static int[] sort(int[] array){

    int temp = 0;

    //外层循环,判断我们这个要走多少次

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

    boolean flag = false;//通过flag标识位减少没有意义的比较

    //内层循环,比较判断两个数,如果第一个数,比第二个数大,则交换位置

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

    if (array[j+1]>array[j]){

    temp = array[j];

    array[j]=array[j+1];

    array[j+1]=temp;

    flag = true;

    }

    }

    if (flag=false)

    break;

    }

    return array;

    }

    }

    稀疏数组

    稀疏数组介绍:

    当一个数组中大部分元素为0,或者为同一值的数组时,可以使用稀疏数组来保存该数组。

    稀疏数组的处理方式是:

    记录数组一共有几行几列,有多少个不同值

    把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模

    如下图:左边是原始数组,右边是稀疏数组

    3bc19466ba4f9316379d7d815f1ca196.png

    package com.kikikikikiku.array;

    public class ArrayDemo09 {

    public static void main(String[] args) {

    //1.创建一个二维数组11*11 0:没有棋子 1:黑棋 2:白棋

    int[][] array1 = new int[11][11];

    array1[1][2] = 1;

    array1[2][3] = 2;

    //输出原始的数组

    System.out.println("输出原始的数组");

    //打印数组

    for (int[] rarray1 : array1) {

    for (int crarray1 : rarray1) {

    System.out.print(crarray1+"\t");

    }

    System.out.println();

    }

    System.out.println("=========================================");

    //转换为稀疏数组保存

    //1.获取有效值的个数

    int sum = 0;

    for (int i = 0; i <11; i++) {

    for (int j = 0; j < 11; j++) {

    if (array1[i][j]!=0)

    sum++;

    }

    }

    System.out.println("有效值的个数:"+sum);

    //2.创建一个稀疏数组的数组

    int[][] array2 = new int[sum+1][3];

    array2[0][0]=11;

    array2[0][1]=11;

    array2[0][2]=sum;

    //3.遍历二维数组,将非0的值存放稀疏数组中

    int count = 0;

    for (int i = 0; i

    for (int j = 0; j < array1[i].length; j++) {

    if (array1[i][j]!=0){

    count++;

    array2[count][0]=i;

    array2[count][1]=j;

    array2[count][2]=array1[i][j];

    }

    }

    }

    //4.输出稀疏数组

    System.out.println("输出稀疏数组");

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

    System.out.println(array2[i][0]+"\t"

    +array2[i][1]+"\t"

    +array2[i][2]+"\t");

    }

    System.out.println("=========================================");

    System.out.println("还原稀疏数组");

    //1.读取稀疏数组

    int[][] array3 = new int[array2[0][0]][array2[0][1]];

    //2.给其中的元素还原它的值

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

    array3[array2[i][0]][array2[i][1]] = array2[i][2];

    }

    //3.打印

    System.out.println("还原的数组");

    //打印数组

    for (int[] rarray1 : array3) {

    for (int crarray1 : rarray1) {

    System.out.print(crarray1 + "\t");

    }

    System.out.println();

    }

    }

    }

    稀疏数组——记录有效的坐标

    小结

    数组是相同数据类型的有序集合

    数组也是对象。数组元素相当于对象的成员变量

    数组长度是确定的,不可变的。如果越界就会报:ArrayIndexOutOfBoundsException

    展开全文
  • package practice; public class ArrayElementsAddIndices { public static void main... System.out.println("原数组中的元素:"); for (int i = 0; i < array.length; i++) { System.out.print(array[i
  • 此类实现:输出一行数组数据,根据输入的下标,以下标位置为结束,将原数组分割成两组子数组。并交换两个子数组的位置,保持子数组中的元素序号不变.如:原数组为7,9,8,5,3,2 以下标3为分割点,分割为子数组一:7,9,8,...
  • package practice; public class ExtremeValueAndIndex { public ... } System.out.println("\n\n最大值:" + max + ",最大值下标:" + maxIndex + "\n\n最小值:" + min + ",最小值下标:" + minIndex); } }
  • import java.util.Scanner; public class IndexOf2ndLargestValue { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int arr[] = new int[10]; for (int i = 0; i &...
  • 给定一个整数数组 nums 和一个目标值 target,请你在该数组中找出和为目标值的那两个整数,并返回他们的数组下标。 算法思想 这种解法不利用排序而是使用哈希表来解决问题。利用迭代将元素插入到map的时候,检查表中...
  • import java.util.Scanner; public class MaximumAndLowerMark { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int arr[] = new int[10]; for (int i = 0; i < ...
  • java基础--输出数组中指定元素的下标java基础--输出数组中指定元素的下标package com.lcn.day05;public class ArrayDemo8 {/*** 输出数组指定元素的下标*/public static void main(String[] args) {//定义一个数组...
  • 数组的只能种整当用户访问JSP文件时,对于HTML标签以及文本的输出形式是()下标型下面选项中,使用post方式提交name=“传智播客”时,得到的结果中没有乱码的是( )各数数C语言中的文件类型只有()。据类人们的真实思想...
  • 自定义一个类,用于存储数值和下标,类似C语言的结构体public class MyArray {private int subscript;private double value;public int getSubscript() {return subscript;}public void setSubscript(int subscript)...
  • 一个学生考试成绩录入程序的模块化设计,在编译时出现了数组下标越界 错误提示:Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0;at Ch3Demo7.main(Ch3Demo7.java:26) ``` class ...
  • public class ArrayDemo8 { ... * 输出数组指定元素的下标 */ public static void main(String[] args) { //定义一个数组 int[] array = new int[]{123,456,789,321,654,987}; int index = p...
  • } } } 那个,大学学了半个月java,想编一个拼图排序的程序。。 怎样在类里面声明并赋值变量然后在class的其他方法里面应用? 以上编码输出为0 0 0 0 0 0 0 0 0 0 求救。。 系统一开始提醒要用static修饰什么的,...
  • 1.Java数组的语法:String[数组下标], Java数组的下标是从0开始的。2.示例代码public class StringArray{public static void main(String[]args){//java数组初始化String[] strArray={"1","2","3"};//输出ja...
  • ``` package model; //价格最低时买入,价格最高时卖出,允许,当天卖出,以便于止损 import java.util.Arrays; public class Horse { ...报错是数组下标越界,但始终找不到原因,请指正,谢谢。
  • 输出数组中最大的值及其下标 */ package lcl02; import java.util.Scanner; public class lcl { static Scanner input = new Scanner(System.in); public static void main(String[] args) { System.out....
  • 我经常遇到数组下标越界问题,看不出来哪里错误,想问大家一般遇到这类问题都怎么处理? 1049. 数列的片段和(20) 时间限制 200 ms 内存限制 65536 kB 代码长度限制 8000 B 判题程序 Standard 作者 CAO, Peng 给定一...
  • 这篇文章主要讲的是数组模拟队列的实现: 队列本身就是有序列表,若是使用数组的结构来存储队列的数据,则队列数组的maxSize就是该队列的最大容量,而由于队列的输出,输入分别是从前后端来处...
  • 给你一份『词汇表』(字符串数组) words 和一张『字母表』(字符串) chars。 假如你可以用 chars 中的『字母』(字符)拼写出 words 中的某个『单词』(字符串),那么我们就认为你掌握了这个单词。 注意:每次...
  • Java数组的输入输出

    万次阅读 多人点赞 2019-08-15 15:28:59
    数组的输入 首先声明一个int型数组 int[] a 或者 int a[] 给数组分配空间 a=new int[10];...//0代表的是数组的第1个元素 ,元素下标为0 a[1]=1;//1代表的是数组的第2个元素 ,元素下标为0 访问数组数据 ...
  • 给定一个乱序数组a,找到所有两个和为target的数组下标index1,index2 使用hash_map,时间复杂度为o(n),空间复杂度为o(n). Exp: a{ 2, 3, 1, 4, 5, 6, 7 },target=6; 输出:0 3  2 4 import java.util....
  • 理解数组下标——有趣程序 1.让用户输入【0,9】范围内整数不定数个 2.统计,输出每个数次数 3.输入-1结束 思路——数据,算法 1.数据 1.输入的数 2.记录每一种数出现次数 程序 import ...
  • 一、将一个给定的整型数组转置输出,例如: 源数组,1 2 3 4 5 6转置之后的数组,6 5 4 3 2 1在看到这道题时,我首先想到的是,创建一个新数组,通过数组下标把一个数组倒着放到另一个数组中,即int[] arr={1,2,3,4,...
  • 输入描述:多案例输入,每个案例的输入第一行为一个整数N,表示小白鼠的数目。...输出描述:每个案例按照白鼠的重量从大到小的顺序输出白鼠的帽子颜色。import java.util.*; import java.math.*; ...
  • 给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 的那 两个 整数,并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。 你...
  •  * 题目:输入数组,最大的与第一个元素交换,最小的与最后一个元素交换,输出数组  * 思路:1.在数组中找出最大数和最小数  * 2.将最大数和最小数的下标记录下来,曾放在一个变量中  * 3.做赋值交换运算 ...
  • 数组inarray中的各个元素按下标逆序输出数组outarray。 例如:inarray={1,5,7,4,2},那么outarray中的元素顺序应该是{2,4,7,5,1} 题目:编写function方法,将数组inarray中的各个元素按下标逆序输出数组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 806
精华内容 322
关键字:

java输出数组下标

java 订阅