day04获取数组的最值，选择排序，冒泡排序，折半查找

/*
给定一个数组{5，1，6，4，2，8，9}。
1.获取数组中最大值，以及最小值。
*/
class  ArrayTest
{

/*
获取数组中最大值
思路：
1.获取最值，需要进行比较，每一次比较都会有一个较大值
因为改值不确定，通过一个变量进行临时存储
2.让数组中每一个元素都和这个变量中的值进行比较
如果大于变量中的值，就用该变量记录较大值。
2.当所有的元素比较完成时，那么该变量中存储数组最大值
步骤：
1.定义变量，初始化位数组中任意一个元素即可
2.通过循环语句对数组进行遍历
3.在变量过程中定义判断条件，如果遍历到元素较大，就赋值给该变量


需要定义一个功能来完成，以便提高复用
1.明确结果，数组中最大元素int
2.未知内容：一个数组int[]
*/
public static int getMax(int[] arr)
{
int max=arr[0];
for (int x=1;x<arr.length ;x++ )
{
if (arr[x]>max)
max=arr[x];
}
return max;
}
/*
获取最大值的另一种方式。
可不可以将临时变量初始化为0呢？
可以，这种方式是在初始化为数组中任意交表。
*/
public static int getMax_2(int[] arr)
{
int max=0;
for (int x=1;x<arr.length ;x++ )
{
if (arr[x]>arr[max])
max=x;
}
return arr[max];
}
/*
获取最小值
*/
public static int getMin(int[] arr)
{
int min=0;
for (int x=1;x<arr.length ;x++ )
{
if(arr[x]<arr[min])
min=x;
}
return arr[min];
}
//获取double类型数组的最大值，因为功能一致
//所以定义相同函数名称，以重载形式存在
public static double
public static void main(String[] args)
{
int [] arr={5,1,6,4,2,8,9};
int min=getMin(arr);
int max=getMax_2(arr);
System.out.println("min="+min);
System.out.println("max="+max);
}

}

/*
对给定数组进行排序
{5,1,6,4,2,8,9}
思路
选择排序
内循环结束一次，最值出现在头角标位置
1.第一个数和后边每一个数进行比较，小的放在第一位
2.第二位
3.
*/
class  ArrayTest2
{
public static void selectSort(int[] arr) //选择排序
{
for (int x=0;x<arr.length-1 ;x++ )
{
for (int y=x+1;y<arr.length ;y++ )
{
if (arr[x]>arr[y])//如果想从高到底，换<符号
{
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}
public static void printArray(int[] arr)//打印数组语句
{
System.out.print("[");
for (int x=0;x<arr.length ;x++ )
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
public static void main(String[] args)//主程序
{
int[] arr={5,1,4,6,2,8,9};
//排序前
printArray(arr);
//排序
selectSort(arr);
//排序后
printArray(arr);
}
}

/*
冒泡排序：相邻的两个元素进行比较，如果符合条件换位
思路：
1.第一个和第二个进行比较，相邻比较，第一圈最值出现在最后位置
2.相邻比较，。。。最值出现在次后尾位置
*/
import  java.util.*;
class  ArrayTest3
{
public static void bubbleSort(int[] arr)
{
for (int x=0;x<arr.length-1 ;x++ )
{
for (int y=0;y<arr.length-x-1 ;y++ )
//-x:让每一次比较元素减少 -1:避免角标越界
{
if (arr[y]>arr[y+1])
{
/*
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
*/
swap(arr,y,y+1);
}
}
}
}
public static void printArray(int[] arr)//打印数组语句
{
System.out.print("[");
for (int x=0;x<arr.length ;x++ )
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
/*
发现无论什么排序，都需要对满足条件的元素进行置换
所以可以把这部分相同的代码提取出来，单独封装成一个函数。
*/
public static void swap(int[] arr,int a,int b)
{
int temp=arr[a];
arr[a]=arr[b];
arr[b]=temp;
}
public static void main(String[] args)//主程序
{
int[] arr={5,1,4,6,2,8,9};
//排序前
printArray(arr);
//排//bubbleSort(arr);
Arrays.sort(arr);//java中已经定义好的一种排列形式，真实的开发，对数组排序，要使用该代码
//排序后序

printArray(arr);
}
}

/*
数组的查找操作。
不会的先在旁边走个画个流程图
练习：有一个有序的数组，想要讲一个元素插入到该数组中，保证有序，
如何获取在元素中的位置
*/
class ArrayTest4 
{
public static void main(String[] args) 
{
//int[] arr={3,1,5,4,2,9};
//int index=getIndex(arr,2);
//System.out.println("index="+index);
int[] arr={2,4,5,7,19,32,45};//8
int index=getIndex_2(arr,8);
System.out.println("index="+index);
}
public static int getIndex_2(int[] arr,int key)
{
int min=0,max=arr.length-1,mid;


while(min<=max)
{
mid=(max+min)>>1;
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
else
return mid;
}
return min;
}
/*
折半的第二种方法
*/
public static int halfSearch_2(int[] arr,int key)
{
int min=0,max=arr.length-1,mid;


while(min<=max)
{
mid=(max+min)>>1;
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
else
return mid;
}
return -1;
}
/*
折半查找，提高效率，但数组必须有序
*/

//定义功能，获取key第一个出现在数组中的位置，如果返回是-1，代表该key在数组中不存在。

}