数组的冒泡排序和折半查找

   冒泡排序（Bubble Sort）是数组中最常见的一种排序方法，它的大概原理是：相邻的两个元素进行比较，如果符合条件就进行换位。

      冒泡排序的特点：

                  <1>.  两两相邻元素进行，第一次比较完以后，小的值都放在前面，大的值放在后面

                  <2>. 最值出现在最后一位

                  <3>. 第二次进行时，最后一位不用参与比较，参与比较元素的长度减少（少了一个元素），依次递减

                  <4>. 也是一种嵌套循环，每一次循环都是从0角标开始

 代码示例：

import java.util.*;

class  ArrayBubble
{
    //定义冒泡排序方法（函数）
    public static void bubbleSort(int[] arr)
    {
        for (int x=0; x<arr.length-1;  x++)  //相邻两个元素进行比较，若只剩下最后一个元素，则不应进行比较，
                                             //所以x<arr.length-1，
                                             //还可以用另一种形式：for(int x=arr.length-1;x>0;x--)
                                                                // for(int y=0; y<x;y++)
        {
            for (int y=0;y<arr.length-x-1;y++)//当第二次进行比较开始后，y就不用再取最后一个元素，所以要减1,一次
                                                                    //内循环参与比较的元素逐次减少，所以x<arr.length-x
            {
                if(arr[y] > arr[y+1]) //做相邻比较，而后面的y+1,不能取到最后一个角标
                                               //所以x<arr.length-x-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 main(String[] args)
    {
        int[]  arr = {5,1,6,4,2,8,9};

        //排序前：
        printArray(arr); 

        //排序：
        bubbleSort(arr);   //调用冒泡排序boobleSort()方法
        //Arrays.sort(arr);

        //排序后：
        printArray(arr);
    }

       发现无论什么排序，都需要对满足条件的元素进行位置置换， 所以可以把这部分相同的代码提取出来，单独封装成一个函数

public static void swap(int[] arr, int a, int b)   {  
    //要交换的是数组里的元素，数组也不确定，所以要将未知的数组传入参数列表
                                              
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b]=temp;
    }
}

折半查找：

class ArrayTest4 {
    public static void main(String[] args) {

         int [] arr = {2,4,5,7,19,32,45};

        //调用折半查找方法halfSearch();
         int index=halfSearch(arr,18);

          System.out.println("index="+index);
    }

第一种查找方法：

       定义查找数组中元素角标的方法(定义功能，获取第一次出现在数组中的位置)，若返回-1，则该key在数组中不存在。若数组中出现两个相同的元素，查找的是第一次出现在数组中的位置

       //定义查找函数(方法)getIndex(),数组和要查找的元素不明确

        public static int getIndex(int[] arr, int key) {
        for (int x=0; x<arr.length; x++ )  {

            if(arr[x]==key)  //如果找到要查找的元素key,就是直接返回该值
                 return x;
        }
        return -1;
    }

折半查找（例：猜数，从0-100之间，猜一个数，从一半的数进行查找）
         可以提高效率，前提条件，该数组必须有序

//定义折半查找的方法helfSearch();

public static int halfSearch(int[] arr, int key) {

        int min,max,mid;
        min = 0;
        max = arr.length-1;
        mid = (min+max)/2;

       //如果要查找的中间值不等于key,就要循环继续查找
        while(arr[mid]!=key)  {

         //如果key大于当前值，则要往大的方向移动，大的角标不变，小的角标要发生改变

            if(key>arr[mid]) 
            
                 min=mid+1;
            else if(key<arr[mid])
                 max=mid-1;
                 mid=(max+min)/2;
                return -1;
        }
        return mid;


    }