二分算法，选择，冒泡排序算法

package com.zlhj.logic.doc;

import java.util.Arrays;

/**
 * 类的作用：
 *
 * @ClassName : Tser
 * @Author : liyang
 * @Date : 2019/1/19  17:00
 * @Version 1.0
 */
/*
 * 冒泡排序
 */
public class Tser {
    public static void main(String[] args) {
        int[] arr = {5, 4, 7, 78, 12, 1, 9, 19, 32, 23};

        Tser tser = new Tser();
        String maop = tser.maopao(arr);
        System.out.println("冒泡排序后的数组为：" + maop);
        String scort = tser.SelectionSort(arr);
        System.out.println("选择排序后的数组为：" + scort);

        int[] arr1 = {5, 4, 7, 78, 12, 9, 19, 32, 23};
        int search1 = tser.halfSearch(arr1, 5);
        int search2 = tser.halfSearch(arr1, 4);
        int search3 = tser.halfSearch(arr1, 7);
        int search4 = tser.halfSearch(arr1, 78);
        int search5 = tser.halfSearch(arr1, 12);
        int search7 = tser.halfSearch(arr1, 9);
        int search8 = tser.halfSearch(arr1, 19);
        int search9 = tser.halfSearch(arr1, 32);
        int search10 = tser.halfSearch(arr1, 23);
        System.out.println("["+search1 + "," + search2 + "," + search3 + "," + search4 + "," + search5 +   "," + search7 +  "," + search8 + "," + search9 +  "," + search10+"]");
    }


    //二分查找法(折半查找法)
    public  int halfSearch(int[] arr,int number){
        int min =0;  //最小下标
        int max =arr.length-1;   //最大下标
        int mid = 0;  //中间下标
        while (min<max){
            //没找到,更新范围继续找
            mid = (min+max)/2;
            if (arr[mid]>number){   //number在mid的左边
                max = mid-1;  //改变最大下标
            }else if(arr[mid]<number){  //number在mid的右边
                min = mid+1;  //改变最小下标
            }else{
                return  mid;
            }
        }
        return -1;
    }



    /**
     * 功能描述：冒泡排序
     */
    public String maopao(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {//外层循环控制排序趟数 。i从0开始循环所以要-1
            for (int j = 0; j < arr.length - 1 - i; j++) {//内层循环控制每一趟排序多少次。j从0开始循环所以要-1在减去i 的长度
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        String str = Arrays.toString(arr);//使用的数组——string中的方法
        return str;
    }

    /**
     * 选择排序
     */
    public String SelectionSort(int[] arr) {
        /*
        a) 原理：每一趟从待排序的记录中选出最小的元素，顺序放在已排好序的序列最后，直到全部记录排序完毕。
        也就是：每一趟在n-i+1(i=1，2，…n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录。
        基于此思想的算法主要有简单选择排序、树型选择排序和堆排序。（这里只介绍常用的简单选择排序）
       b) 简单选择排序的基本思想：
       给定数组：int[] arr={里面n个数据}；
       第1趟排序，在待排序数据arr[1]~arr[n]中选出最小的数据，
       将它与arrr[1]交换；第2趟，在待排序数据arr[2]~arr[n]中选出最小的数据，
       将它与r[2]交换；以此类推，第i趟在待排序数据arr[i]~arr[n]中选出最小的数据，将它与r[i]交换，直到全部排序完成。
         */
        //选择排序的优化
        for (int i = 0; i < arr.length - 1; i++) {// 做第i趟排序
            int k = i;
            for (int j = k + 1; j < arr.length; j++) {// 选最小的记录
                if (arr[j] < arr[k]) {
                    k = j; //记下目前找到的最小值所在的位置
                }
            }
            //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
            if (i != k) {  //交换a[i]和a[k]
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }
        }
        String str = Arrays.toString(arr);//使用的数组——string中的方法
        return str;
    }


}