数组的常见操作：冒泡排序 选择排序与取最值

import java.util.*;
public class ArrayDemo2 {
    /*
     其他操作：
     获取最值；
     排序（选择排序，冒泡排序）；
     折半查找（二分查找）
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = {89,34,270,17};
        System.out.println("arr.length="+arr.length);
        printArray(arr);
        //bubbleSort(arr);
        Arrays.sort(arr);
        printArray(arr);//开发
        System.out.println("Max="+getMax(arr));

    }
    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]+"]");
        }
    }
    /*
     获取数组中的最大值：
     思路：
     1，定义变量，赋值为一个数组中的值。
     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;
    }
    public static int getMax_2(int[] arr) {
        int max = 0;
        for(int x=1; x<arr.length; x++)
        {
            if(arr[x] > arr[max])
                arr[max] = arr[x];
        }
        return arr[max];
    }
    /*
     选择排序
     明确一：结果
             无结果，内部排序 void
     明确二：未知数
            有 数组
     思路：1.从第一位开始遍历，将最小值放到第一位
     */
    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;
                    temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
    }
    /*
     冒泡排序
     明确一：结果
            无， void
     明确二：未知数
            有 数组
     思路：
     每一次冒泡都能解决一个位置，因此有array.length-1个位置需要解决。外圈循环为length-1
     而单次冒泡需要遍历比较到已确定的位置之处
     */
    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++){
//这个地方 y的范围-1是因为下方的if判定需要y+1，若不-1会越界
//-x则是因为单次冒泡的遍历比较是到已确定的位置为止的，外圈每循环一次，则确定一个值的位置。
                if(arr[y] > arr[y+1]){
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                }
            }
        }
    }
    /*
     冒泡排序2
     同样的思路，但是可以更简略
     */
    public static void bubbleSort2(int[] arr) {
        for(int x=arr.length-1 ; x<=0; x++){
            for(int y=0; y<x; y++){
                if(arr[y] > arr[y+1]){
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                }
            }
        }
    }
}