26.Java数组的直接排序、冒泡排序、折半查找及数组的翻转

1.直接排序

直接选择排序(Straight Select Sorting) 也是一种简单的排序方法，它的基本思想是：第一次从R[0]~R[n-1]中选取最小值，与R[0]交换，第二次从R[1]~R[n-1]中选取最小值，与R[1]交换，....，第i次从R[i-1]~R[n-1]中选取最小值，与R[i-1]交换，.....，第n-1次从R[n-2]~R[n-1]中选取最小值，与R[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。

例如:给定n=8，数组R中的8个元素的排序码为(8,3,2,1,7,4,6,5),则直接选择排序的过程如下所示：

初始状态 [ 8 3 2 1 7 4 6 5 ] 8 -- 1

第一次 [ 1 3 2 8 7 4 6 5 ] 3 -- 2

第二次 [ 1 2 3 8 7 4 6 5 ] 3 -- 3

第三次 [ 1 2 3 8 7 4 6 5 ] 8 -- 4

第四次 [ 1 2 3 4 7 8 6 5 ] 7 -- 5

第五次 [ 1 2 3 4 5 8 6 7 ] 8 -- 6

第六次 [ 1 2 3 4 5 6 8 7 ] 8 -- 7

第七次 [ 1 2 3 4 5 6 7 8 ] 排序完成

/*
    选择排序。
    以一个角标的元素和其他元素进行比较。
    在内循环第一次结束，最值出现的头角标位置上。
    */
public static void selectSort(int[] arr)
    {
        for(int x=0; x<arr.length-1; x++)
        {
            for(int y=x+1; y<arr.length; y++)//为什么y的初始化值是 x+1？            因为每一次比较，
                                            //都用x角标上的元素和下一个元素进            行比较。
            {
                if(arr[x]>arr[y])
                {
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
      }

2.冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

冒泡排序算法的原理如下： 

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。 
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

例如:给定n=8，数组R中的8个元素的排序码为(8,3,2,1,7,4,6,5),则冒泡排序的过程如下所示：

初始状态 [ 8 3 2 1 7 4 6 5 ] 

第一次 [ 3 2 1 7 4 6 5 8 ] 

第二次 [ 2 1 3 4 6 5 7 8 ] 

第三次 [ 1 2 3 4 5 6 7 8 ] 排序完成

/*
    冒泡排序。
    比较方式：相邻两个元素进行比较。如果满足条件就进行位置置换。
    原理：内循环结束一次，最值出现在尾角标位置。
    */
    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;
                }
            }
        }
}

3.折半查找(二分法)

算法思想

二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。

首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

 

/*
    为了提高查找效率，可使用折半查找的方式，注意：这种查找只对有序的数组有效。
    这种方式也成为二分查找法。
    */
    public static int halfSeach(int[] arr,int key)
    {
        int min,mid,max;
        min = 0;
        max = arr.length-1;
        mid = (max+min)/2;

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

4.数组翻转

/*
    反转其实就是头角标和尾角标的元素进行位置的置换，
    然后在让头角标自增。尾角标自减。
    当头角标<尾角标时，可以进行置换的动作。
    */
    public static void reverseArray(int[] arr)
    {
        for(int start=0,end=arr.length-1; start<end; start++,end--)
        {
            swap(arr,start,end);
        }
    }
    //对数组的元素进行位置的置换。
    public static void swap(int[] arr,int a,int b)
    {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }