数组排序_冒泡排序_选择排序_插入排序_二分法

数组的排序

1.冒泡排序

//冒泡排序
/*
	两两比较,较大的值往后放,第一次比较完毕,最大值出现在最大索引处
	依次这样比较,可以得到排好序的数组!
*/

public class bubbleSort {
	
	public static void main(String[] args){
		int[] arr = {8,7,6,5,4,3,2,1,0} ;
		System.out.println("排序前：");
		printArray(arr);
		System.out.println("冒泡排序后：");
		Sort(arr);
		printArray(arr);
	}
		 
	public static void printArray(int[] arr) {
		System.out.print("[");
		for(int i = 0 ; i < arr.length ;i++) {
			if(i == arr.length-1) {
				System.out.println(arr[i] + "]");
			}else {
				System.out.print(arr[i] + ", ");
			}
		}
	}
		 
	public static void Sort(int[] arr) {
		for(int i = 0 ; i < arr.length-1 ; 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 ;
				}
			}
		} 
	}	  
}

public static void selectSort(int[] arr) {
    for (int x = 0; x < arr.length-1; x++) {
        for (int y = x + 1; y < arr.length; y++) {
            //如果后面的 元素比前面小,互换
            if (arr[y] < arr[x]) {
                int temp = arr[x];
                arr[x] = arr[y];
                arr[y] = temp;
            }
        }
    }
}

2.选择排序

//选择排序
public class selectionSort {
	public static void main(String[] args) {
		int[] arr = {8,7,![在这里插入图片描述](https://img-blog.csdnimg.cn/95ac58e7758743d1bcbe7fb844a1bb45.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk1Njg5OA==,size_16,color_FFFFFF,t_70)
6,5,4,3,2,1,0} ;
		System.out.println("排序前：");
		printArray(arr);
		System.out.println("排序后：");
		selection(arr);
		printArray(arr);
	}
	
	public static void printArray(int[] arr) {
		System.out.print("[");
		for(int i = 0 ; i < arr.length ;i++) {
			if(i == arr.length-1) {
				System.out.println(arr[i] + "]");
			}else {
				System.out.print(arr[i] + ", ");
			}
		}
	}
    
    //方式一
    public static void selectSort1(int[] arr){
        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 ;
                }
            }
        }
    }
	//方式二
	public  static void selection(int[] arr) {
		for(int i = 0 ; i < arr.length-1 ; i++) {
			
			int Index = i ;//记录最小索引
            
			for(int j = i+1 ; j < arr.length ; j++) {
				if(arr[Index] > arr[j]) {
					Index = j ;
				}
			}
			//i不是最小时，将i和最小数进行交换
			if(i != Index) {
				int swap = arr[Index] ;
				arr[Index] = arr[i] ; 
				arr[i] = swap ;
			}
		}
	}
}

3.插入排序

插入排序   时间复杂度:O(N^2)
       核心思想:使用1角标对应的元素进行和0角标比较
       如果前面元素大,向右移动,确定角标1对应的元素的位置,再次使用2角标对应的元素依次和1和0都元素比较
       依次这样比较....
       
       Integer类:包含了int类型的值:
       Integer实现自然排序(默认升序排序)
           public int compareTo(Integer anotherInteger) {      //  8  34
              return compare(this.value, anotherInteger.value);
                               8,34
          }
                                8          34
      public static int compare(int x, int y) {  //提高程序的执行效率
          return (x < y) ? -1 : ((x == y) ? 0 : 1);
      }

public class InsertSortTest {
    public static void main(String[] args) {
        //定义一个Integer数组: Integer实现的自然排序:元素能够按照升序默认排序
        Integer[] arr = {34,8,64,51,32,21} ;
        System.out.println("排序前:");
        printArr(arr);
        //定义一个功能
        insertSort(arr) ;
        System.out.println("排序后:");
        printArr(arr);
    }
    //插入排序
    
    /*---方式1---*/
    private static void insertSort(Integer[] arr) {
        //定义一个变量j
            int j ; //j记录当前角标的变化
            //定义变量 : p:表示一个比较次数 p=1,2,3,4,5 (每一移动的元素的位置)
            for(int p = 1 ; p < arr.length ; p ++ ){ //比较次数     p=2
                //定义临时变量temp
                Integer temp = arr[p] ;    //temp = 8;          temp = 64
                //开始比较
                for(j = p ; j>0 && temp.compareTo(arr[j-1])<0; j-- ){  // j= 1 ; 1>0&& 8 < 34   j-- : j= 0
                    //j=2 ; 2>0 && 64 < 32
                    //数据移动
                    arr[j] = arr[j-1] ;
                }
                //确定temp的位置:8的位置   64的位置:p=2
                arr[j] = temp ;         // 没有移动
        }
    }
    /*---方式2---*/
   public static void insertion(int[] arr) {
		int current ;
		int Index ;
		for(int i = 1 ; i < arr.length ; i ++) {
			current = arr[i] ;
			Index = i - 1 ;
			while(Index >= 0 && current < arr[Index] ) {
				arr[Index+1] = arr[Index] ;
				Index-- ;
			}
			arr[Index+1] = current ;
		}
	}
    public static void printArr(Integer[] arr){
        System.out.print("[");
        for(int x = 0 ; x < arr.length ; x ++){
            if(x == arr.length -1){
                System.out.println(arr[x] +"]");
            }else{
                System.out.print(arr[x]+", ");
            }
        }
    }
}

4.二分法

数组高级查找算法之二分搜索算法
    前提条件数组必须有序,如果数组本身无序,让我们查询元素,先排序再去查找!(有条件需求先排序,再查
    如果没有条件需求,只能使用基本元素查找法:从头查找到尾)
如果需求明确要求手动书写,直接可以使用工具类即可!
  Arrays工具类:
        里面提供排序sort(任何数组进行排序) :元素升序排序 Integer,String
        里面提供二分搜素法(任何类型进行查询 ,int key)
        	public static int binarySearch(数组 , 数据)  api

public class BinarySearch {
    public static void main(String[] args) {
        //已知数组,静态初始化
        int[] arr = {11,22,33,44,55} ;
        //调用二分搜索方法查询
        int index = binarySearch(arr, 22);
        System.out.println(index);
    }
    //返回值int
    //方法参数:数组,查询的元素
    public static int binarySearch(int[] arr,int target){
        //防止空指针异常
        if(arr!=null){
            //定义数组的最小索引:
            int min = 0 ;
            //定义最大索引
            int max = arr.length -1 ;
            //使用循环while
            while(min<=max){
                //计算中位点索引
                int mid = (min+max)/2 ;
                //如果当前中位点对应的元素小于要要查找的元素
                if(target < arr[mid]){
                    //左半区域:继续折半
                    max = mid -1 ;
                }else if(target > arr[mid]){
                    //右边区域:继续折半
                    min = mid + 1 ;
                }else{
                    //查询到了
                    return mid ;
                }
            }
        }
        //循环结束之后,还没有找,则返回-1
        return -1 ;
    }
}