数组

数组

数组是相同数据类型多个数据的容器,数组中的元素是按线性顺序排列的。类似一张单链表,除了第一个元素之外,其余都有唯一前驱元素;除了最后一个元素外,其余都有唯一后继元素。要注意的是,数组一旦初始化成功,则它在内存空间中申请的存储空间就是固定的,无法更改。为数组扩容的办法一般是将小容量的数组添加到大容量的数组中。创建数组一般有两种方法。

方法一:

数据类型[] 数组名称 = {数据1,数据2,数据3...数据n}

int[] array = {1,2,3,4,5};
方法二:

数据类型[] 数组名称 = new 数据类型[数组长度]

int[] array = new int[5]

#####不常用的数组定义格式:

创建数组但不初始化:数据类型[] 数组名。这样创建后续就必须先指定长度(初始化)才能赋值。

int[] array;
array = new int[5];
array[0] = 1;

创建数组,指定内容。数据类型[] 数组名称 = new int[] {数据1,数据2,数据3...数据n}

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

多维数组创建方法:

方法一(只定义一维):
int[][] array = new array[10][];
方法二(维数全部定义):
int[][] array = new array[10][10];

几种常用的查找排序方法:

冒泡排序:

外层循环控制轮数(array.length-1),内层循环控制每轮比较次数(array.length-i-1)

public static void main(String[] args) {
   //定义一个无序数组。
   int[] array = {1,6,7,4,5,8};
   //外层循环,要比较的轮数。
   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]) {
               //交换数组中两个数的位置。
               array[j] = array[j]^array[j+1];
               array[j+1] = array[j]^array[j+1];
               array[j] = array[j]^array[j+1];
          }
   //打印出数组中元素。
   for (int i = 0; i < array.length; i++) {
       System.out.println(array[i]);
  }
}
二分查找:

必须是一组有序的数据(顺序或者逆序),每次可以减少一半要查找的数据量。一般可以先将数据排序之后再进行二分查找。

public static void main(String[] args) {
   //定义一个无序数组。
   int[] array = {1,6,7,4,5,8};
   //外层循环,要比较的轮数。
   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]) {
               //交换数组中两个数的位置。
               array[j] = array[j]^array[j+1];
               array[j+1] = array[j]^array[j+1];
               array[j] = array[j]^array[j+1];
          }
   //打印出数组中元素。
   for (int i = 0; i < array.length; i++) {
       System.out.print(array[i] + ",");
  }
   System.out.println();
   //二分查找,寻找数组中是否有要查找的值以及如果有的话打印出它的位置。
   Scanner input = new Scanner(System.in);
   System.out.print("请输入要查找的数字:");
   //判断键盘输入值是否是整数。
   if (!input.hasNextInt()) {
       System.out.println("请输入一个整数。");
  } else {
       //输入的要查找的数字。
       int n = input.nextInt();
       //二分查找的数据集所在数组的左下标。初始为最小值。
       int left = 0;
       //二分查找的数据集所在数组的右下标。初始为最大值。
       int right = array.length-1;
       //二分查找的要比较的值。
       int i = (left + right)/2;
       //无限循环查找直到找到或数组中没有这个值跳出。
       while (true) {
           if (n > array[i]) {
               //由于数据集是由大到小排列的,所以如果要查找的数大于比较的数,
               //就代表二分后左边的那个数据集是可能包含要查找的那个数。将右下标重新置于已经比较的元素左边一位。
               right = i - 1;
               //重新计算要比较的元素位置。
               i = (left + right)/2;
          } else if (n < array[i]) {
               //由于数据集是由大到小排列的,所以如果要查找的数小于比较的数,
               //就代表二分后右边的那个数据集是可能包含要查找的那个数。将右下标重新置于已经比较的元素右边一位。
               left = i + 1;
               //重新计算要比较的元素位置。
               i = (left + right)/2;
          } else {
               //在数据集中找到了元素。
               System.out.println("您查找的数据在数组中的位置为:" + i + "。");
               break;
          }
           if (left > right) {
               //在数据集中找不到要找的元素。
               System.out.println("在数组中未找到该数据。");
               break;
          }
      }
  }
}

作业

/** 
* main:(程序执行的入口).
* @author
* @param args 命令行参数
* @since JDK 1.8
*/
public static void main(String[] args) {
   /**1、查找某个整数
    * 定义一个长度为10的整型数组nums ,
    * 循环输入10个整数。然后将输入一个整数,查找此整数,
    * 找到输出下标,没找到给出提示。
    */
   int[] nums = new int[10];
   Scanner input = new Scanner(System.in);
   for (int i = 0; i < nums.length; i++) {
       System.out.println("请输入第"+ (i+1) + "个整数:");
       //判断输入的数是否是整数。
       if(input.hasNextInt())
           nums[i] = input.nextInt();
       else
           System.out.println("请输入整数。");
  }
   //外层循环,要比较的轮数。
   for (int i = 0; i < nums.length-1; i++)
       //内层循环,每轮要比较的次数。
       for (int j = 0; j < nums.length-1-i; j++)
           //如果前一个数小于后一个数。
           if (nums[j] < nums[j+1]) {
               //交换数组中两个数的位置。
               nums[j] = nums[j]^nums[j+1];
               nums[j+1] = nums[j]^nums[j+1];
               nums[j] = nums[j]^nums[j+1];
          }
   //打印出数组中元素。
   for (int i = 0; i < nums.length; i++) {
       System.out.print(nums[i] + ",");
  }
   System.out.println();
   //二分查找,寻找数组中是否有要查找的值以及如果有的话打印出它的位置。
   System.out.print("请输入要查找的数字:");
   //判断键盘输入值是否是整数。
   if (!input.hasNextInt()) {
       System.out.println("请输入一个整数。");
  } else {
       //输入的要查找的数字。
       int n = input.nextInt();
       //二分查找的数据集所在数组的左下标。初始为最小值。
       int left = 0;
       //二分查找的数据集所在数组的右下标。初始为最大值。
       int right = nums.length-1;
       //二分查找的要比较的值。
       int i = (left + right)/2;
       //无限循环查找直到找到或数组中没有这个值跳出。
       while (true) {
           if (n > nums[i]) {
               //由于数据集是由大到小排列的,所以如果要查找的数大于比较的数,
               //就代表二分后左边的那个数据集是可能包含要查找的那个数。将右下标重新置于已经比较的元素左边一位。
               right = i - 1;
               //重新计算要比较的元素位置。
               i = (left + right)/2;
          } else if (n < nums[i]) {
               //由于数据集是由大到小排列的,所以如果要查找的数小于比较的数,
               //就代表二分后右边的那个数据集是可能包含要查找的那个数。将右下标重新置于已经比较的元素右边一位。
               left = i + 1;
               //重新计算要比较的元素位置。
               i = (left + right)/2;
          } else {
               //在数据集中找到了元素。
               System.out.println("您查找的数据在数组中的位置为:" + i + "。");
               break;
          }
           if (left > right) {
               //在数据集中找不到要找的元素。
               System.out.println("在数组中未找到该数据。");
               break;
          }
      }
  }
}
/** 
* main:(程序执行的入口).
* @author
* @param args 命令行参数
* @since JDK 1.8
*/
public static void main(String[] args) {
/**2、找出数组的最值
* 定义一个长度为10的整型数组nums ,循环输入10个整数。
* 输出数组的最大值、最小值。
*/
int[] nums = new int[10];
Scanner input = new Scanner(System.in);
for (int i = 0; i < nums.length; i++) {
System.out.println("请输入第"+ (i+1) + "个整数:");
//判断输入的数是否是整数。
if(input.hasNextInt())
nums[i] = input.nextInt();
else
System.out.println("请输入整数。");
}
   //外层循环,要比较的轮数。
   for (int i = 0; i < nums.length-1; i++)
       //内层循环,每轮要比较的次数。
       for (int j = 0; j < nums.length-1-i; j++)
           //如果前一个数小于后一个数。
           if (nums[j] < nums[j+1]) {
               //交换数组中两个数的位置。
          nums[j] = nums[j]^nums[j+1];
          nums[j+1] = nums[j]^nums[j+1];
          nums[j] = nums[j]^nums[j+1];
          }
   System.out.println("最大值为:" + nums[0]);
   System.out.println("最小值为:" + nums[nums.length-1]);
}
```java
/**
* main:(程序执行的入口).
* @author
* @param args 命令行参数
* @since JDK 1.8
*/
public static void main(String[] args) {
/**3、两数之和
* 给定一个整数数组nums 和一个目标值target,
* 请你在该数组中找出和为目标值的那两个整数,
* 并输出他们的数组下标假设每种输入只会对应一个答案,
* 不能重复利用这个数组中同样的元素。
* Tips:这里基于题目做了更改,让它可以查找无序整数集合中
* 的所有与输入值匹配的数组元素的下标组合(非重复下标组合)。
*/
//1. 定义一个数组,这个数组中包含重复的元素以及多个满足target的下标组合。
int[] nums = {2,1,3,3,1,7,11,15,21,5,6,85,56,12,98,78,2,2,2,2};
//2. 数组中元素从小到大进行冒泡排序。
bubbleSort(nums);
//3. 创建键盘输入对象。
Scanner input = new Scanner(System.in);
System.out.println("请输入一个目标值:");
//4. 使用者可以多次输入target值。
while(true) {
//5. 判断是否输入整数。
if (input.hasNextInt()) {
//6. 输入target。
int target = input.nextInt();
//7. 从最小值开始一个个查找满足target的组合。
int left = 0;
//8. 查找数组中多个满足target的组合。
while(true) {
//9. target减去一个当前循环的最小值判断是否小于0,
// 如果小于0则没有满足条件的组合跳出循环,查找结束。
// 否则就以减去后留下的值进行二分查找,在数组中找到所有满足条件的值。
int searchNum = target - nums[left];
if (searchNum < 0) {
System.out.println("查找结束。");
break;
}
//10. 定义一个列表存储当前循环满足target的值的下标组合。
List<Integer> result = binarySearch(nums, searchNum, left+1);
//11. target不为空则找到了至少一组组合,打印出来所有组合。
if (!result.isEmpty()) {
for (Integer n : result) {
System.out.println("数组中第"+left+"个元素的值:"+nums[left]+"与");
System.out.println("数组中第"+n+"个元素的值:"+nums[n]);
System.out.println("相加等于:"+target);
}
}
//12. 如果没有碰到数组右边界,则将最小下标向右移动一位继续寻找下一个满足条件的组合。
// 否则跳出当前循环,查找结束。
if (left < nums.length-1) {
left++;
continue;
} else {
System.out.println("查找结束。");
break;
}
}
}else {
System.out.println("请输入一个整数。");
break;
}
}
}
/**
* bubbleSort:(冒泡排序).
* @author
* @param nums 要排序的数组
* @since JDK 1.8
*/
public static void bubbleSort(int[] nums) {
   //外层循环,要比较的轮数。
   for (int i = 0; i < nums.length-1; i++)
       //内层循环,每轮要比较的次数。
       for (int j = 0; j < nums.length-1-i; j++)
           //如果前一个数小于后一个数。
           if (nums[j] > nums[j+1]) {
               //交换数组中两个数的位置。
          nums[j] = nums[j]^nums[j+1];
          nums[j+1] = nums[j]^nums[j+1];
          nums[j] = nums[j]^nums[j+1];
          }
}
/**
* binarySearch:(二分查找).
* @author
* @param nums 要查找的数据集
* @param target 要查找的元素
* @param left 开始查找的下标最小值
* @return 要查找的元素在数据集中的位置
* @since JDK 1.8
*/
public static List<Integer> binarySearch(int[] nums, int target, int left) {
//列表存储所有查找得到的值的下标。
List<Integer> result = new ArrayList<Integer>();
int leftBound = left;
   //二分查找的数据集所在数组的右下标。初始为最大值。
   int right = nums.length-1;
   //二分查找的要比较的值。
   int i = (left + right)/2;
   //无限循环查找直到找到或数组中没有这个值跳出。
   while (true) {
       if (target > nums[i]) {
           //由于数据集是由小到大排列的,所以如果要查找的数大于比较的数,
           //就代表二分后右边的那个数据集是可能包含要查找的那个数。将左下标重新置于已经比较的元素右边一位。
           left = i + 1;
           //重新计算要比较的元素位置。
           i = (left + right)/2;
      } else if (target < nums[i]) {
           //由于数据集是由小到大排列的,所以如果要查找的数小于比较的数,
           //就代表二分后左边的那个数据集是可能包含要查找的那个数。将右下标重新置于已经比较的元素左边一位。
           right = i - 1;
           //重新计算要比较的元素位置。
           i = (left + right)/2;
      } else if (target == nums[i]){
      //将找到的元素的下标添加进列表中。
      result.add(i);
      int flag = i;
      //向左寻找所有相同的值。
      while(target == nums[flag-1] && flag > leftBound) {
      flag--;
      result.add(flag);
      }
      //重置标志。
      flag = i;
      //向右寻找所有相同的值。
      while(target == nums[flag+1] && flag < nums.length-2) {
      flag++;
      result.add(flag);
      }
           //在数据集中找到了元素。
           break;
      }
       if (left > right) {
           //在数据集中找不到要找的元素。
           break;
      }
  }
return result;
}
/** 
* main:(程序执行的入口).
* @author
* @param args 命令行参数
* @since JDK 1.8
*/
public static void main(String[] args) {
/**4、排序并查找
* 对数组{1,3,9,5,6,7,15,4,8}进行排序,
* 然后使用二分查找元素6并输出排序后的下标。
*/
//定义一个无序数组。
int[] array = {1,3,9,5,6,7,15,4,8};
//外层循环,要比较的轮数。
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]) {
//交换数组中两个数的位置。
array[j] = array[j]^array[j+1];
array[j+1] = array[j]^array[j+1];
array[j] = array[j]^array[j+1];
}
//打印出数组中元素。
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + ",");
}
System.out.println();
//二分查找,寻找数组中是否有要查找的值以及如果有的话打印出它的位置。
Scanner input = new Scanner(System.in);
System.out.print("请输入要查找的数字:");
//判断键盘输入值是否是整数。
if (!input.hasNextInt()) {
System.out.println("请输入一个整数。");
} else {
//输入的要查找的数字。
int n = input.nextInt();
//二分查找的数据集所在数组的左下标。初始为最小值。
int left = 0;
//二分查找的数据集所在数组的右下标。初始为最大值。
int right = array.length-1;
//二分查找的要比较的值。
int i = (left + right)/2;
//无限循环查找直到找到或数组中没有这个值跳出。
while (true) {
if (n > array[i]) {
//由于数据集是由大到小排列的,所以如果要查找的数大于比较的数,
//就代表二分后左边的那个数据集是可能包含要查找的那个数。将右下标重新置于已经比较的元素左边一位。
right = i - 1;
//重新计算要比较的元素位置。
i = (left + right)/2;
} else if (n < array[i]) {
//由于数据集是由大到小排列的,所以如果要查找的数小于比较的数,
//就代表二分后右边的那个数据集是可能包含要查找的那个数。将右下标重新置于已经比较的元素右边一位。
left = i + 1;
//重新计算要比较的元素位置。
i = (left + right)/2;
} else {
//在数据集中找到了元素。
System.out.println("您查找的数据在数组中的位置为:" + i + "。");
break;
}
if (left > right) {
//在数据集中找不到要找的元素。
System.out.println("在数组中未找到该数据。");
break;
}
}
}
}
/** 
* main:(程序执行的入口).
* @author
* @param args 命令行参数
* @since JDK 1.8
*/
public static void main(String[] args) {
/**5、移动零
* 给定一个数组nums,编写一个函数将所有0移动到数组的末尾,
* 同时保持非零元素的相对顺序。
*/
int[] nums = {0,1,0,3,12};
move(nums);
for (int i = 0; i < nums.length; i++) {
System.out.println(nums[i]);
}
}
public static void move(int[] nums) {
for (int i = 0; i < nums.length-1; i++) {
for (int j = 0; j < nums.length-i-1; j++) {
if (nums[j] == 0) {
nums[j] = nums[j]^nums[j+1];
nums[j+1] = nums[j]^nums[j+1];
nums[j] = nums[j]^nums[j+1];
}
}
}
}
/** 
* main:(程序执行的入口).
* @author
* @param args 命令行参数
* @since JDK 1.8
*/
public static void main(String[] args) {
/**今天同学们相约一起爬山游玩,为了更好的进行这场活动,大家准备推举一个人作为出游的临时队长。
* 为了体现合理公平,大家提出了一个比较有趣的规则。所有人围成一圈,顺序排号。
* 从第一个人开始报数(从1到3报数),凡报到3的人退出圈子,剩下的人继续报数,最后留下的当选为队长。
* 请你通过编写程序,求出一组人中的队长是原来第几位同学。
*/
int[] allStudents = {1,2,3,4,5,6,7,8};
int leader = selectTeamLeader(allStudents);
System.out.println("第"+leader+"位同学是队长。");
}
/**
* selectTeamLeader:(选择队长).
* @author
* @param allStudents 全部学生的集合
* @return 第几个人是队长
* @since JDK 1.8
*/
public static int selectTeamLeader(int[] allStudents) {
int length = allStudents.length;
int[] winStudents = new int[length - length/3];
int winer = 0;
int remainder = 0;
while (true) {
for (int i = 0; i < length; i++) {
if ( (i+remainder+1) % 3 != 0 ) {
winStudents[winer] = allStudents[i];
winer++;
}
}
if (winStudents.length == 1)
break;
winer = 0;
remainder = (length%3 + remainder)%3;
allStudents = winStudents;
length = allStudents.length;
winStudents = new int[length - (length+remainder)/3];
}
return winStudents[0];
}

 

posted @ 2021-08-09 21:08  leafruomu  阅读(23)  评论(0)    收藏  举报