Java中数组（冒泡，选择，插入）排序算法以及二分查找

1.冒泡排序

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

package Test;

public class Test {
    public static void main(String[] args) {
        int arr[] = {45, 56, 12, 78, 15, 9};
        Print(arr);
        MaoShort(arr);
        System.out.println();
        Print(arr);
    }
    public static void MaoShort( int arr []){
        for (int i = 0; i <arr.length; i ++ )
        {
            for (int j = 1; j < arr.length  ; j ++ )
            {
                if (arr[j] < arr [j-1])
                {
                    int temp = arr[j];
                    arr [j] = arr[j - 1];
                    arr [j - 1] = temp;
                }
            }
        }
    }
    public static void Print(int arr []){
        for (int i = 0; i < arr.length ; i++ )
        {
            System.out.print(arr[i] + "  " );
        }
    }
}

2.插入排序

插入排序是指在待排序的元素中，假设前面n-1(其中n>=2)个数已经是排好顺序的，现将第n个数插到前面已经排好的序列中，然后找到合适自己的位置，使得插入第n个数的这个序列也是排好顺序的。按照此法对所有元素进行插入，直到整个序列排为有序的过程，称为插入排序

 

package Test;

public class Test {
    public static void main(String[] args) {
        int arr[] = {45, 56, 12, 78, 15, 9};
        Print(arr);
        ChaShort(arr);
        System.out.println();
        Print(arr);
    }

    public static void ChaShort(int arr []){
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j > 0; j--) {
                if (arr[j] < arr[j-1]){
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j -1] = temp;
                }
            }
        }
    }

    public static void Print(int arr []){
        for (int i = 0; i < arr.length ; i++ )
        {
            System.out.print(arr[i] + "  " );
        }
    }
}

3.选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。 

 

package Test;

public class Test {
    public static void main(String[] args) {
        int arr[] = {45, 56, 12, 78, 15, 9};
        Print(arr);
        XuanShort(arr);
        System.out.println();
        Print(arr);
    }

    public static void XuanShort(int arr []){
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[i]){
                    int temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
    }

    public static void Print(int arr []){
        for (int i = 0; i < arr.length ; i++ )
        {
            System.out.print(arr[i] + "  " );
        }
    }
}

4.二分查找

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

特点：针有序的序列，可以直接查找中间值，大于中间值则在后半部分，反之则在前面

//二分查找，循环完成
public static int ECha01(int[] arr, int key) {
        int start = 0,end = arr.length -1;
        while (start <= end){
            int mind = (start + end) / 2;
            if (arr[mind] > key){
                end = mind - 1;
            }else if (arr[mind] < key){
                start = mind + 1;
            }
            else {
                return mind;
            }
        }
        return -1;
    }

// 二分查找，递归完成
	public static int binarySearch(int[] arr, int target, int start, int end) {
		if (start > end) {
			return -1;
		}
 
		int middle = (start + end) / 2;
		if (target == arr[middle]) {
			return middle;
		} else if (target > arr[middle]) {
			return binarySearch02(arr, target, middle + 1, end);
		} else {
			return binarySearch02(arr, target, start, middle - 1);
		} 
	}