常见的排序算法和二分法查找算法

【排序算法】

一、冒泡排序

      每次对相邻的两个元素进行比较，若前者大于后者则进行交换，如此一轮下来最后一轮的就是最大元素，接着进行下一轮的比较，

      需要注意的是下一轮的比较要将上一轮确定的最大的那个元素除外，重复以上的步骤，直到没有要比较的元素。

         

             

               

                  

 

二、选择排序

       选择排序(Selection sort)的工作原理是:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,

       然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。

                 

                  

                     

                       

三、代码实现

                     

package Test;

public class Sort {
    public static void main(String[] args) {
        traversal(bubble_Sort(create_int_arr(2,5)));
        traversal(selection_Sort(create_int_arr(3,7)));
    }

    public static void traversal(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            if (i == 0) {
                System.out.print("{ " + arr[i]+", ");
            }else if (i == arr.length-1) {
                System.out.println( arr[i]+" }");
            }else {
                System.out.print(arr[i]+", ");
            }
        }
    }

    /**
     * 冒泡排序
     * @param arr 传入数组作为参数
     * @return 返回排好序的数组
     */
    public static int[] bubble_Sort(int[] arr){
        //外层for用来控制排序的趟数
        for (int i = arr.length-1; i>=0; i--) {
            int tmp;
            //内层for循环用来控制每趟排序的次数
            for (int j = 0; j < i; j++) {
                if (arr[j]>arr[j+1]) {
                   tmp = arr[j];
                   arr[j] = arr[j+1];
                   arr[j+1] = tmp;
                }
            }
        }
        return arr;
    }

    /**
     * 选择排序
     * @param arr 传入一个数组
     * @return 返回排好序的数组
     */
    public static int[] selection_Sort(int[] arr){
        //外层for用来控制排序的趟数
        for (int i = 0 ; i < arr.length - 1; i++) {
            //内层for循环用来控制每趟排序的次数
            for (int j = i; j < arr.length -1; j++) {
                if(arr[j+1] < arr[i]){
                    int tmp = arr[i];
                    arr[i] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
        return arr;
    }

    public static int[] create_int_arr(int digit,int len){
        int[] arr =  new int[len];
        switch (digit){
            case 1:
                for (int i = 0; i < len ; i++) {
                    arr[i] = (int)(10*Math.random()+1);
                }
                break;
            case 2:
                for (int i = 0; i < len ; i++) {
                    arr[i] = (int)(100*Math.random()+1);
                }
                break;
            case 3:
                for (int i = 0; i < len ; i++) {
                    arr[i] = (int)(1000*Math.random()+1);
                }
                break;
            case 4:
                for (int i = 0; i < len ; i++) {
                    arr[i] = (int)(10000*Math.random()+1);
                }
                break;
        }
        return arr;
    }
}

 

【查找算法】

一、二分法查找原理

1、二分法查找的前提条件：
        该数组必须是已经排好序的数组（有序数组）
2、二分法查找的原理：
        二分法查找算法又叫折半查找算法，在一个有序的序列中，根据要查找的目标数据和序列的中间位置上的元素
        进行大小比较，比较的结果有三种情况：
           1）目标数据 = 中间位置上元素的值，即找到目标元素所在的位置
           2）目标数据 > 中间位置上元素的值, 在中间位置的右侧查找
           3)目标数据 < 中间位置上元素的值, 在中间位置的左侧查找
        循环 2）和 3）直到 1）出现
二、二分法查找代码实现

        

package Test;

public class BinarySearch {
    public static void main(String[] args) {
        //traversal(create_int_arr((int)(5*Math.random()+1),4));
        //traversal(create_int_arr(3,8));
        int[] arr1 = {13,916,178,861,773,829,92,323};
        int[] arr = selection_Sort(arr1);
        int index = binarySeach(arr,773);
        System.out.println((index == -1)?("要查找的元素不存在"):("要查找的元素的下标为："+index));
    }

    /**
     * 该方法实现有序数组的二分法查找
     * @param arr 该参数代表传入的是一个int类型的数组
     * @param dest_ele 该参数为要查找的目标元素
     * @return 方法的返回值为-1时，表示没找到目标元素；返回值为其他时，表示返回了目标元素的下标
     */
    public static int binarySeach(int[] arr,int dest_ele){
        int begin_index = 0;
        int end_index = arr.length -1;
        //只要开始元素的下标在结束元素的左边，就一直循环
        while(begin_index <= end_index){
            //中间元素下标
            int mid_index = (begin_index + end_index)/2;
            //目标元素刚好在中间位置上
            if (arr[mid_index] == dest_ele) {
                System.out.println("元素："+dest_ele+"的下标为："+mid_index);
                return mid_index;
            //目标元素在中间位置的右侧
            }else if(arr[mid_index]