目录
1.求数组的平均值
2.数组所有元素之和
3.改变原有数组元素的值
4.打印数组
5.创建的数组，并且赋初始值
6.存在连续三个奇数的数组
7.多数元素
8.只出现一次的数字
9.两数之和
10.冒泡排序
11.数组是否有序
12.二分查找
13.数组的拷贝
14.数组转字符串
1.求数组的平均值
实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型).
public class array {
//基于数组的日常练习
public static void main(String[] args) {
//求数组的平均值
//实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型).
int[] arr = {1,9,3,5,4};
System.out.println(arrAvg(arr));
}
//先得定义一个数组 遍历数组 求数组长度 求个元素和 然后和/长度=平均值
public static int arrSum(int[] arr){
int ret = 0;
for (int i = 0; i < arr.length; i++) {
ret += arr[i];
}
return ret;
}
public static double arrAvg(int[] arr){
double ret = 0.0;
double sum = arrSum(arr);
ret = sum / arr.length;
return ret;
}
}
2.数组所有元素之和
实现一个方法 sum, 以数组为参数, 求数组所有元素之和.
public class array {
public static void main(String[] args) {
int[] arr = {1,9,3,5,4};
//2.数组所有元素之和
System.out.println(arrSum(arr));//22
}
public static int arrSum(int[] arr){
int ret = 0;
for (int i = 0; i < arr.length; i++) {
ret += arr[i];
}
return ret;
}
}
3.改变原有数组元素的值
实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上. 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
public class array {
public static void main(String[] args) {
// int[] arr = new int[3];
// arr[0]=1;
// arr[1]=2;
// arr[2]=3
int[] arr = {1,2,3};//定义一个数组，并初始化
int[] ret = transform(arr);
printArr(arr);
System.out.println();
printArr(ret);
}
//打印数组元素
private static void printArr(int[] arr){
for (int i : arr) { //不改变数组内部元素
System.out.print(i + " ");
}
}
public static int[] transform(int[] arr){
int[] ret = new int[arr.length] ; //新创建一个数组，跟原数组等长，不改变原数组元素
for (int i = 0; i < arr.length; i++) {
ret[i] = arr[i]*2;
}
return ret;
}
}
4.打印数组
实现一个方法 printArray, 以数组为参数, 循环访问数组中的每个元素, 打印每个元素的值.
public class array {
public static void main(String[] args) {
int[] arr = {1,9,3,5,4};
String ret = arrPrint(arr);
System.out.print(ret);//[1,9,3,5,4]
}
// 实现一个方法 printArray, 以数组为参数,
// 循环访问数组中的每个元素, 打印每个元素的值.
public static String arrPrint(int[] arr){
String ret = "[";
for (int i = 0; i < arr.length; i++) {
ret+=arr[i];
if (i != arr.length-1){ // i < arr.length-1
ret += ",";
}
}
ret += "]";
return ret;
}
}
5.创建的数组，并且赋初始值
创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100
import java.util.Arrays;
public class array {
public static void main(String[] args) {
int[] a=new int[100];
setNumber(a);
System.out.println(Arrays.toString(a));
}
//创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100
public static int[] setNumber(int[] arr){
for (int i = 0; i < 100; i++) {
arr[i] = i+1;
}
return arr;
}
}
6.存在连续三个奇数的数组
给你一个整数数组arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。
示例 1：输入：arr = [2,6,4,1] 输出：false
解释：不存在连续三个元素都是奇数的情况。
示例 2：输入：arr = [1,2,34,3,4,5,7,23,12] 输出：true
解释：存在连续三个元素都是奇数的情况，即 [5,7,23] 。
public class array {
public static void main(String[] args) {
int[] a1 = {2,6,4,1};
numOdd(a1);
int[] a2 ={1,2,34,3,4,5,7,23,12};
numOdd(a2);
}
//6.给你一个整数数组arr，请你判断数组中是否存在连续三个元素都是奇数的情况：
// 如果存在，请返回true；否则，返回false。
public static int numOdd(int[] arr){
int count = 0;
for (int i = 0; i < arr.length-2; i++) {
if(arr[i]%2==1 && arr[i+1]%2==1 && arr[i+2]%2==1){
count++;
}
}
if (count!=0){
System.out.println(true);
} else{
System.out.println(false);
}
return count;
}
}
7.多数元素
给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 n/2 的元素。你可以假设数组是非空的，并且给定的数组总是存在多数元素。
示例 1： 输入：[3,2,3] 输出：3
示例 2： 输入：[2,2,1,1,1,2,2] 输出：2
import java.util.Arrays;
public class array {
public static void main(String[] args) {
System.out.print("arr1的多数元素为：");
int[] arr1 = {3,2,3};
System.out.print(searchMost(arr1));
System.out.print("\narr2的多数元素为：");
int[] arr2 = {2,2,1,1,1,2,2};
System.out.print(searchMost(arr2));
}
//给定一个大小为 n的数组，找到其中的多数元素。多数元素是指在数组中出现次数
//大于n/2的元素。你可以假设数组是非空的，并且给定的数组总是存在多数元素。
/**
* 将数组排序，则中间的那个元素一定是多数元素
* 该代码的时间复杂度为O（NlogN）
* @param arr 整形数组
* @return
*/
public static int searchMost(int[] arr){
Arrays.sort(arr); //对数组元素排序
return arr[arr.length/2];
}
}
8.只出现一次的数字
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
示例 1: 输入: [2,2,1] 输出: 1
示例 2: 输入: [4,1,2,1,2] 输出: 4
public class array {
public static void main(String[] args) {
int[] arr1 = {2,2,1};
System.out.println(searchOne(arr1));
int[] arr2 = {4,1,2,1,2};
System.out.println(searchOne(arr2));
}
//8.给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均
//出现两次。找出那个只出现了一次的元素。
//异或操作 —— 任何数异或0都等于任何数
public static int searchOne(int[] arr){
int temp = 0;
for (int i = 0; i < arr.length; i++) {
temp^=arr[i];
}
return temp;
}
}
9.两数之和
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。
示例 ：
输入：nums = [2,7,11,15], target = 9 输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
public class array {
public static void main(String[] args) {
int[] nums = {2,7,11,15};
searchSum(nums,9);
}
//9.给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出
// 和为目标值 target的那两个整数，并返回它们的数组下标。你可以假设每种
// 输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可
// 以按任意顺序返回答案。
// target = nums[i] + nums[j] ——>return i , j
public static int searchSum(int[] nums, int target){
for (int i = 0; i < nums.length; i++) {
for (int j = 1; j < nums.length; j++) {
if (target == nums[i]+nums[j]){
System.out.print("["+i+","+j+"]");//单纯的控制输出格式
}
}
}
return target;
}
}
10.冒泡排序
给定一个整型数组, 实现冒泡排序(升序排序)
public class array {
public static void main(String[] args) {
//10.冒泡排序 升序排序
//双重循环
int[] arr = {1, 8, 5, 0, 3, 7, 4};
// 外层循环控制 冒的轮数
for (int i = 0; i < arr.length / 2; i++) {
// 内层循环控制相邻两个数，若前一个数大于后一个数 则交换两数
// PS: j的越界问题
for (int j = 0; j < arr.length - i-1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.println("升序排序为：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" "); //0 1 3 4 5 7 8
}
}
}
11.数组是否有序
给定一个整型数组, 判定数组是否有序（递增）
public class array {
public static void main(String[] args) {
int[] arr1 = {1,2,3,4,5,6,7};
System.out.println(arryJudge(arr1));
int[] arr2 = {3,6,2,5,1,4};
System.out.print(arryJudge(arr2));
}
//给定一个整型数组, 判定数组是否有序（递增）
public static boolean arryJudge(int[] arr){
for (int i = 0; i < arr.length-1; i++) {
if (arr[i] > arr[i+1]){
return false;
}
}
return true;
}
}
12.二分查找
给定一个有序整型数组, 实现二分查找
public class array {
public static void main(String[] args) {
int[] arr = {1,3,5,7,9,11,13,17};
System.out.println(searchBinary(arr,2)); //-1
System.out.println(searchBinary(arr,17)); //17
}
// 12.二分查找
/**
* 有序整型数组, 实现二分查找
* @param arr
* @param target 要找的数
* @return
*/
public static int searchBinary(int[] arr,int target){
int left = 0;
int right = arr.length-1;
while(left <= right){
int middle = (left+right)>>1;
if (target == arr[middle]){
return arr[middle]; //返回要找的那个数值
}else if (target < arr[middle]){
right = middle-1;
}else{
left = middle+1;
}
}
return -1;//未找到
}
}
13.数组的拷贝
实现一个方法 copyOf, 对一个整型数组进行拷贝, 得到一个新的数组.
import java.util.Arrays;
public class array {
public static void main(String[] args) {
// 13.
int[] arr = {3,7,2,4,8};
int[] newarr = arryCopy(arr);//调用方法arryCopy
System.out.println(Arrays.toString(newarr));//Arrays.toString将数组转换成String类型输出
}
//13.实现一个方法 copyOf, 对一个整型数组进行拷贝, 得到一个新的数组。
public static int[] arryCopy(int[] arr) {
int[] ret = new int[arr.length];//保持数组大小不变
for (int i = 0; i < arr.length; i++) {
ret[i] = arr[i];
}
return ret;
}
}
14.数组转字符串
实现一个方法 toString, 把一个整型数组转换成字符串. 例如数组 {1, 2, 3} , 返回的字符串为 "[1, 2, 3]", 注意 逗号 的位置和数量.
public class array {
public static void main(String[] args) {
int[] arr = {3,7,2,4,8};
System.out.println(arrToStr(arr));
}
// 14.实现一个方法 toString, 把一个整型数组转换成字符串.
// 例如数组 {1, 2, 3} , 返回的字符串为 "[1, 2, 3]", 注意逗号的位置和数量.
public static String arrToStr(int[] arr){
String ret = "[";
for (int i = 0; i < arr.length; i++) {
ret += arr[i];
if (i<arr.length-1){
ret += ",";
}
}
ret += "]";
return ret;
}
}
本小节完^_^
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
