数组练习整理

/*
需求： 定义一个函数接收一个int类型的数组对象，找出数组对象中 的最大元素返回给调用者。

*/

class Demo8 
{
    public static void main(String[] args) 
    {
        int[] arr = {-12,-14,-5,-26,-4};
        int max = getMax(arr);
        System.out.println("最大值："+ max); 
    }


    public static int  getMax(int[] arr){
        int max = arr[0]; //用于记录最大值
        for(int i = 1 ; i < arr.length ; i++){
            if(arr[i]>max){  //如果发现有元素比max大，那么max变量就记录该元素。
                max = arr[i];
            }
        }
        return max;
    }


}

/*
需求： 定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的第一位。

选择排序(直接排序)：使用一个元素与其他 的元素挨个比较一次，符合条件交换位置。


*/
class Demo9{

    public static void main(String[] args) 
    {
        int[] arr = {12,5,17,8,9};  //对于5元素的数组，只需要找出4个最大值就可以排序了。
        selectSort(arr);
    }

    public static void selectSort(int[] arr){

        //把最大值放在首位置。
        for(int j = 0; j<arr.length-1; j++){  //  控制的是轮数。
            for(int i = j+1 ; i<arr.length ; i++){ // 找出最大值
                if(arr[i]>arr[j]){
                    //交换位置
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }


/*
        //把老二放在第二个位置
        for(int i = 2  ; i< arr.length ; i++){
            if(arr[i]>arr[1]){
                int temp = arr[i];
                arr[i] = arr[1];
                arr[1] = temp;
            }
        }


        //把老三放在第三个位置
        for(int i = 3  ; i< arr.length ; i++){
            if(arr[i]>arr[2]){
                int temp = arr[i];
                arr[i] = arr[2];
                arr[2] = temp;
            }
        }

        //把老四放在第四个位置
        for(int i = 4  ; i< arr.length ; i++){
            if(arr[i]>arr[3]){
                int temp = arr[i];
                arr[i] = arr[3];
                arr[3] = temp;
            }
        }

/*
需求： 定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的最后一位。

冒泡排序：冒泡排序的思想就是使用相邻的两个 元素挨个比较一次，符合条件交换位置。

*/

class Demo10
{
public static void main(String[] args)
{
int[] arr = {12,8,17,5,9}; // 最大的索引值: 4 容量：5
bubbleSort(arr);
}

public static void bubbleSort(int[] arr){
    // 把最大值放在最后一个位置
    for(int j = 0 ; j<arr.length-1 ; j++){ //控制轮数
        for(int i = 0 ; i<arr.length-1-j  ; i++){  // 找出一个最大值  
            //相邻的元素比较
            if(arr[i]>arr[i+1]){
                int temp  = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
    }

/*

    //把老二放在倒数第二个位置上。
    for(int i = 0 ;  i <arr.length-1-1 ; i++){
        if(arr[i]>arr[i+1]){
            int temp = arr[i];
            arr[i] = arr[i+1];
            arr[i+1] = temp;
        }   
    }


    //把老三放在倒数第三个位置上。
    for(int i = 0 ;  i <arr.length-1-2 ; i++){
        if(arr[i]>arr[i+1]){
            int temp = arr[i];
            arr[i] = arr[i+1];
            arr[i+1] = temp;
        }   
    }

    //把老四放在倒数第四个位置上。
    for(int i = 0 ;  i <arr.length-1-3 ; i++){
        if(arr[i]>arr[i+1]){
            int temp = arr[i];
            arr[i] = arr[i+1];
            arr[i+1] = temp;
        }   
    }

*/

    //遍历数组，查看效果
    System.out.print("目前的元素：");
    for (int i = 0 ; i<arr.length  ;i++){
        System.out.print(arr[i]+",");
    }

}

}

/*
需求：定义一个函数接收一个数组对象和一个要查找的目标元素，函数要返回该目标元素在
数组中的索引值，如果目标元素不存在数组中，那么返回-1表示。

折半查找法(二分法): 使用前提必需是有序的数组。

*/
class Demo12
{
public static void main(String[] args)
{
int[] arr = {12,16,19,23,54};
//int index = searchEle(arr,23);
int index = halfSearch(arr,116);
System.out.println(“元素所在的索引值是：”+ index);
}

public static int halfSearch(int[] arr, int target){
    //定义三个变量分别记录最大、最小、中间的查找范围索引值
    int max = arr.length-1;
    int min = 0;
    int mid = (max+min)/2;
    while(true){
        if(target>arr[mid]){
            min = mid+1;
        }else if(target<arr[mid]){
            max = mid -1;
        }else{
            //找到了元素
            return mid;
        }

        //没有找到的情况
        if (max<min){
            return -1;
        }

        //重新计算中间索引值
        mid = (min+max)/2;
    }

}




public static int searchEle(int[] arr, int target){
    for(int i = 0 ; i<arr.length ; i++){
        if(arr[i]==target){
            return i;
        }
    }
    return -1;
}

}

/*
需求： 定义 一个函数接收一个char类型的数组对象,然后翻转数组中的元素。

char[] arr = {‘a’,’b’,’c’,’d’,’e’};

*/
class Demo13
{
public static void main(String[] args)
{
//System.out.println(“Hello World!”);
char[] arr = {‘a’,’b’,’c’,’d’,’e’};
reverse(arr);

}

public static void reverse(char[] arr){
    for(int startIndex = 0 ,endIndex = arr.length-1 ;   startIndex<endIndex ; startIndex++,endIndex--){
        char temp = arr[startIndex];
        arr[startIndex] = arr[endIndex];
        arr[endIndex] = temp;
    }

    //遍历数组，查看效果
    System.out.print("目前的元素：");
    for (int i = 0 ; i<arr.length  ;i++){
        System.out.print(arr[i]+",");
    }

}

}

/*
toString();
排序（sort）
找元素在数组中的位置(二分查找法) binarySearch

数组的工具类（Arrays）：

作业1： 自定实现一个Arrays的toString方法。

*/
import java.util.*;
class Demo14
{

public static void main(String[] args) 
{
    int[] arr = {12,3,1,10,8};
    //排序的方法
    Arrays.sort(arr);  
    String info = Arrays.toString(arr);
    System.out.println("数组的元素："+ info);

    // 1, 3, 8, 10, 12  
    int index = Arrays.binarySearch(arr,9);// 二分法查找 : 如果能在数组中找到对应 的元素，那么就返回该数据的索引值，如果没有找到那么就返回一个负数表示。
    System.out.println("找到的索引值："+ index);

}

}

“`