Java一一数组排序 冒泡排序，选择排序，插入排序；二分法查找

冒泡排序：

排序思路：比较两个相邻的下标对应的元素，如果符合条件就交换位置（最值出现在最后位）

代码实现：

package com.qf0818;

import java.util.Arrays;

/**
 * 2019/8/1817:21
 * <p>
 * 未知的事情 永远充满变数
 */
public class Demo1 {
    public static void main(String[] args) {
        int [] arr = new int []{12,34,6,8,4,2,90};

        int [] arr1 =test(arr);
        System.out.println("冒泡排好序之后："+Arrays.toString(arr1));
       

    }


    //冒泡排序      优化时 如果第二层循环没有发生交换
    public static int []  test(int [] arr){
        for (int i =0 ;i<arr.length;i++){
              
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
  
                }

             }
           
		 }

        return arr;
    }
}

优化：

如果提前排好序后 程序并不清楚，因此还会继续执行 这个时候在一层循环里添加一个boolean变量设置初值为true 在二曾循环交换后设置为false

如图所示（Eclipse演示）

代码：

    //冒泡排序      优化时 如果第二层循环没有发生交换
    public static int []  test(int [] arr){
        for (int i =0 ;i<arr.length;i++){
                //优化
                boolean fiag = true;
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                    fiag = false;

                }

                }
            if(fiag){
                System.out.println("提前排好结束！");
                break;
            }


        }
        System.out.println("排序后："+Arrays.toString(arr));
        return arr;
    }

选择排序：

排序思路：固定一个下标，然后拿这个下标对应的值依次和后面的元素进行比较

画图分析：

代码实现：

class ArraySortedDemo02 
{
	public static void main(String[] args) 
	{
		int[] arr = {23,54,65,3,5,2,87};
		//以升序为例
		//外层循环：控制比较的轮数
		for(int i = 0;i < arr.length - 1;i++) {
			//内层循环:控制每一轮比较的次数，参与比较的下标
			for(int j = i + 1;j < arr.length;j++) {
				//交换位置
				if(arr[i] > arr[j]) {
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
		
		for(int num:arr) {
			System.out.println(num);
		}
	}
}

优化后：

//选择排序  2 优化
    public static void test03(int [] arr){
            for (int i=0;i<arr.length;i++){
                boolean flag=false;
                int pow =i;
                for (int j = i+1; j <arr.length-1 ; j++) {
                    if(arr[pow]>arr[j]){
                        pow = j;
                        flag= true;

                    }
                }
                if(flag){
                    int temp = arr[i];
                    arr[i]=arr[pow];
                    arr[pow]= temp;
                }

            }
        System.out.println("选着排序后："+ Arrays.toString(arr));
    }

插入排序：

代码：

  //插入排序
    public static void test05(int [] arr){
        for (int i=0;i<arr.length;i++){
            int pow=i;  定义一个指针 指向待比较元素
            int curr=arr[pow];  获取出待比较的值 找见位置后在放到指定位置
            for (int j = i-1;j >=0;j--) {
               if(curr<arr[j]){
                   arr[j+1]=arr[j]; // 把不符合要求的数后移
                   pow--;				// 指针往前移动

               }
            }
            if(pow!=i){
                arr[pow]=curr;  //把值放到合适位置
            } 

        }

        System.out.println("插入排序后："+Arrays.toString(arr));
    }

二分法查找：

查找思路：前提是数组是有序（升序或者降序）的，通过折半来缩小查找范围，提高查找效率

将待查找的元素与中间下标对应的元素比较，如果大于中间下标对应的元素，则去右半部分查找

 //二分法查找
    public static int test02(int [] arr,int value){
        int low=0,heigh=arr.length-1;
        while (low<=heigh){
            int mid = (low+heigh)/2;
            if(arr[mid]==value){
                return mid;
            }else if (arr[mid]>value){
                heigh=mid-1;
            }else if(arr[mid]<value){
                low=mid+1;
            }

        }
        return -1;

    }