数组相关操作
package amqp.publisher;
import java.util.*;
/**
* @ProjectName: day01
* @Package: amqp.publisher
* @ClassName: compare
* @Author: Vector
* @Date: 2021/12/21 15:03
* @Description: 当你的才华还撑不起你的野心的时候，你就应该静下心来学习。当你的能力还驾驭不了你的目标的时候，你就应该沉下心来历练。
*/
public class ArrayTools {
/**
* 比较并计算出数组中的最大值
* @param arr
*/
public static int compareToMax(int [] arr){
//擂台，先放第一个人上去
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i]>max){
max = arr[i];
}
}
return max;
}
/**
* 比较并计算出数组中的最小值
* @param arr
*/
public static int compareToMin(int [] arr){
//擂台，先放第一个人上去
int min = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i]<min){
min = arr[i];
}
}
return min;
}
/**
* 比较数组中元素并进行排序 从小到大
* 解决方案 ：每个元素和自己后面的元素进行比较大小，大于后面元素，则进行换位；相邻两数比较，不满足顺序就交换
*
* 索引0和后面每个数字比较
* 60 2 59 6 80 100
* 60 > 2 -> 2 60 59 6 80 100 交换位置
* 60 > 59 -> 2 59 60 6 80 100 交换位置
* 60 > 6 -> 2 59 6 60 80 100 交换位置
* 60 > 80 -> 2 59 6 60 80 100 不交换位置
* 60 > 100 -> 2 59 6 60 80 100 不交换位置
* 结束第一次比较 共需要比较5次 length-0-1 = 5
*
* 索引1和后面每个数字比较
* 2 59 6 60 80 100
* 59 > 6 -> 2 6 59 60 80 100 交换位置
* 59 > 60 -> 2 6 59 60 80 100 不交换位置
* 59 > 80 -> 2 6 59 60 80 100 不交换位置
* 59 > 100 -> 2 6 59 60 80 100 不交换位置
* 结束第二次比较 共需要比较4次 length-1-1 = 4
*
* 索引2和后面每个数字比较
* 2 6 59 60 80 100
* 59 > 60 -> 2 6 59 60 80 100 不交换位置
* 59 > 80 -> 2 6 59 60 80 100 不交换位置
* 59 > 100 -> 2 6 59 60 80 100 不交换位置
* 结束第三次比较 共需要比较3次 length-2-1 = 3
*
* 索引3和后面每个数字比较
* 2 6 59 60 80 100
* 60 > 80 -> 2 6 59 60 80 100 不交换位置
* 60 > 100 -> 2 6 59 60 80 100 不交换位置
* 结束第四次比较 共需要比较2次 length-3-1 = 2
*
* 索引4和后面每个数字比较
* 2 6 59 60 80 100
* 80 > 100 -> 2 6 59 60 80 100 不交换位置
* 结束第五次比较 共需要比较1次 length-4-1 = 1
*
* 最后得出结论:
* 数组长度为6的数组
* 需要执行length-i-1次的比较来排序
* 使用二维数组循环，外层数组控制比较元素的索引，内层数组控制元素比较
* @param arr
*/
public static int[] sort(int [] arr){
//外层数组控制比较的轮数，每执行一轮，就可以得出一个最小的数，最小的数不需要参与后续比较，所以轮数-1
for (int i = 0; i < arr.length-1; i++) {
boolean isChanged = false;
//每执行一轮，就可以得到一个最小的数，最小的数不参与后续比较，所以轮数-1，即arr.length-1
//每一轮的索引开始位置是i,所以循环的次数还需要减去索引，即arr.length-i-1
for (int j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j+1]){
int temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
isChanged = true;
}
if (!isChanged){
System.out.println("数组已经有序不需要比较!");
break;
}
}
}
return arr;
}
public static List<Integer> sort2(int [] arr){
List<Integer> list = new ArrayList<>();
for (int i = 0; i < arr.length; i++) {
list.add(arr[i]);
}
Collections.sort(list);
return list;
}
public static void sort3(int [] arr){
Arrays.sort(arr);
}
/**
*
* @param arr 待查找的数组
* @param findValue 需要在数组中找到的数字
* @return int 返回的是数字在数组中的索引位置
* //二分法查找 前提是有顺序
* //1、定义头位置 定义尾位置
* //2、定义中间位置，与输入的数字进行比较
* //3、如果比中间数大，头会变成中间位置+1
* //4、如果比中间数小，尾部变成中间位置-1
* //5、如果只有一个元素，比完就结束了
* //6、只要找到就立刻结束
*
*/
public static int findDichotomy(int [] arr,int findValue){
//定义头位置和尾位置
int start = 0;
int end = arr.length-1;
//当开始索引小于
while (start<=end){
//当开始索引等于结束索引，数组中只有一个元素
if (end == start){
if (arr[start] == findValue){
System.out.println("已找到数据"+findValue+",数据索引是："+start);
return start;
}else {
System.out.println("未找到数据"+findValue);
return -1;
}
}
int median = (start+end)/2;
if (arr[median]>findValue){
end = end - 1;
}else if (arr[median]<findValue){
start = start + 1;
}else if (arr[median]==findValue){
System.out.println("已找到数据"+findValue+",数据索引是："+median);
return median;
}
}
return -1;
}
/**
* 反转数组
* 1、就是对称位置的元素交换
* 2、通常遍历数组用的是一个索引
* int i = 0;
* 现在表示对称位置需要两个索引
* int min = 0
* int max = arr.len-1
* 3、交换两个变量，引入第三个变量
* int temp = 0;
* temp = max;
* max = min;
* min = max;
* 4、交换终止判断：
* 如果数组长度是奇数-> min == max
* 如果数组长度是偶数-> min > max
* 所以只需要满足：min < max 应该交换
* @param arr
*/
public static void reverse(int [] arr){
for (int min = 0,max=arr.length-1; min < max; min++,max--) {
int temp = arr[min];
arr[min] = arr[max];
arr[max] = temp;
}
}
/**
* 使用新数组来反转原数组并返回新数组
* @param arr
* @return
*/
public static int[] reverse2(int [] arr){
int [] newArr = new int[arr.length];
for (int i = 0; i < newArr.length; i++) {
newArr[i] = arr[arr.length-i-1];
}
return newArr;
}
/**
* 通过二分法进行数组反转
* 1,2,3
* 只需要把1和3的位置对调
* int temp = arr[0] ,
* arr[0] = arr[arr.length-0-1],
* arr[arr.length-0-1] = temp;
* 需要3/2=1次
* 1,2,3,4
* 需要把1和4,2和3的位置对调
* int temp = arr[0] ,
* arr[0] = arr[arr.length-0-1],
* arr[arr.length-0-1] = temp;
*
* int temp = arr[1] ,
* arr[1] = arr[arr.length-1-1],
* arr[arr.length-1-1] = temp;
* 需要4/2=2次
* @param arr
*/
public static void reverse3(int [] arr){
for (int i = 0; i < arr.length/2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length-i-1];
arr[arr.length-i-1] = temp;
}
}
/**
* 通过集合的reverse方法实现数组反转
* @param arr
* @return
*/
public static List<Integer> reverse4(int [] arr){
List<Integer> list = new ArrayList<>();
for (int i = 0; i < arr.length; i++) {
list.add(arr[i]);
}
Collections.reverse(list);
return list;
}
public static void main(String[] args) {
int [] arr = {10,25,-20,60,90};
int max = compareToMax(arr);
System.out.println("最大值是:"+max);
System.out.println("========================");
int min = compareToMin(arr);
System.out.println("最小值是:"+min);
System.out.println("========================");
reverse3(arr);
System.out.println("反转后的数组为：");
for (int i = 0; i < arr.length; i++) {
System.out.print("\t"+arr[i]);
}
System.out.println("\n========================");
sort3(arr);
System.out.println("排序后的数组为：");
for (int i = 0; i < arr.length; i++) {
System.out.print("\t"+arr[i]);
}
int [] brr = {10,25,40,60,90};
System.out.println("\n========================");
int dichotomy = findDichotomy(brr, 60);
System.out.println("数字在数组中的索引为："+dichotomy);
}
}
171
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
