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;
    }


}

二分算法，選擇，冒泡排序算法