冒泡排序, 插入排序,选择排序,二分法查找(数组算法)

import java.util.Arrays;

/**
 * 冒泡排序, 插入排序,选择排序,二分法查找(数组算法)
 */
public class Demo03 {
    public static void main(String[] args) {
        int[] a={2,35,5,7,4,7,4,3,8,9};
        BubbleSort(a);
        InsertionSort(a);
        SelectionSort(a);
    }

    /**
     * 冒泡排序
     *  算法描述
     *
     * 1.比较相邻的元素。如果第一个比第二个大，就交换它们两个；
     * 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
     * 3.针对所有的元素重复以上的步骤，除了最后一个；
     * 4.重复步骤1~3，直到排序完成。
     */
    public static void BubbleSort(int a[]){
        for (int i=0;i<a.length;i++){
            for (int j=0;j<a.length-1;j++){
                if (a[j]>a[j+1]){
                    int temp=a[j+1];
                    a[j+1]=a[j];
                    a[j]=temp;
                }
            }
        }
        System.out.println("a = " + Arrays.toString(a));
    }
    /**
     * 插入排序
     * 1.从第一个元素开始，该元素可以认为已经被排序；
     * 2.取出下一个元素，在已经排序的元素序列中从后向前扫描；
     * 3.如果该元素（已排序）大于新元素，将该元素移到下一位置；
     * 4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
     * 5.将新元素插入到该位置后；
     * 重复步骤2~5。
     */
    public static void InsertionSort(int[] a){
        int j;
        for (int i=1;i<a.length;i++){
            int t=a[i];
            for (j=i;j>0&&t<a[j-1];j--){
                a[j]=a[j-1];
//                if(a[i]>a[j]){
//                    a[j+1]=a[i];
//                }
            }
            a[j]=t;
        }
        System.out.println("a = " + Arrays.toString(a));
    }
    /**
     * 选择排序
     * 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
     * 然后，再从剩余未排序元素中继续寻找最小（大）元素，
     * 然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕
     */
    public static void SelectionSort(int[] a){
        for (int i=0;i<a.length-1;i++){
            int index=i;
            for (int j=i;j<a.length;j++){
                if(a[j]<a[index]){
                    index=j;
                }
            }
            int temp=a[index];
            a[index]=a[i];
            a[i]=temp;
        }
        System.out.println("a = " + Arrays.toString(a));
        BinarySearch(a,7);
    }

    /**
     * 二分查找
     * 算法前提：必须采用顺序存储结构，按照关键字大小有序排列。适用于不经常变动查找频繁的表。
     */
    public static void BinarySearch(int[] a,int target){
        int start=0;
        int end=a.length-1;
        while (start<end){
            int mid=(start + end) / 2;
            if(a[mid]<target){
                start=mid+1;
            }else if (a[mid]>target){
                end=mid-1;
            }else {
                System.out.println("你要查找的值得下标为 ：" + mid);
                break;
            }
        }
    }
}