2019-06-13 java学习日记

冒泡排序

两个相邻位置比较，如果前面的元素比后面的元素大就换位置

//冒泡排序
    public static void main(String[] args) {
        int[] arr = {32, 44, 55, 65, 11};
        bubble(arr);
        print(arr);
    
        
    }


    private static void bubble(int[] arr) {
        //外循环只需要比较数组的长度-1次
        for (int i = 0; i < arr.length - 1; i++) {
        //内循环 -1是为了防止索引越界，-i是为了提高效率
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //这里这个大于小于是决定他是从大到小还是从小到大
                if (arr[j] > arr[j + 1]) {
                    int a = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = a;
                }
            }
            
        }
    }
    //打印
    private static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

选择排序

用一个索引位置上的元素，依次与其他索引位置上的元素比较，小在前面大的在后面

public static void main(String[] args) {
        int[] arr = {32, 44, 55, 65, 11};
        bubble(arr);
//      select(arr);
        print(arr);
    }
    /**
     * 选择排序
     * 1、返回值类型void
     * 2、参数列表int[] arr
     */
    public static void selectSort(int[] arr) {
      //只需要比较arr.length-1次
        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;    */
                    swap(arr, i, j);
                }
            }
        }
    }
    /**
     * 打印数组
     * 1、返回值类型void
     * 2、参数列表int[] arr
     */
    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
    /**
     * 换位操作
     * 1、返回值类型，void
     * 2、参数列表int[] arr.int i,int j
     * 
     * 如果某个方法,只针对本类使用,不想让其他类使用就可以定义成私有的
     */
    private static void swap(int[] arr,int i,int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

二分查找

如果数组无序，就不能使用二分查找

public static void main(String[] args) {
            int[] arr = {11,22,33,44,55,66,77};
            System.out.println(getIndex(arr, 22));
            System.out.println(getIndex(arr, 66));
            System.out.println(getIndex(arr, 88));
        }
        /**
         * 二分查找
         * 1、返回值类型int
         * 2、参数列表int[] arr,int value
         * 
         */
        public static int getIndex(int[] arr, int value) {
            int min = 0;
            int max = arr.length - 1;
            int mid = (min + max) / 2;
           //当中间值不等于要找的值,就开始循环查找
            while (arr[mid] != value) {     
           //当中间值小于了要找的值
                if (arr[mid] < value) {     
           //最小的索引改变
                    min = mid + 1;              
           //当中间值大于了要找的值
                }else if (arr[mid] > value) {   
           //最大的索引改变
                    max = mid - 1;               
                }
           //无论最大还是最小改变,中间索引随之改变     
                mid = (min + max) / 2;           
           //如果最小索引大于了最大索引,就没有查找的可能性了     
                if (min > max) {            
           //返回-1           
                    return -1;                    
                }
            }
            return mid;
        }

Arrays类的概述

针对数组进行操作的工具类

提供了排序,查找等功能

Arrays类的成员方法

1，public static String toString(int[] a)

2，public static void sort(int [] a)

3，public static int binarySearch(int [] a,int key)

package com.array;

import java.util.Arrays;

public class Demo3 {

    public static void main(String[] args) {
        int[] arr = {33,66,44,55,11,22};
        System.out.println(Arrays.toString(arr));             //数组转字符串  
        
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));             //排序
        
        int[] arr2 = {11,22,33,44,55,66};
        System.out.println(Arrays.binarySearch(arr2, 22));
        System.out.println(Arrays.binarySearch(arr2, 66));
        System.out.println(Arrays.binarySearch(arr2, 88));    //-插入点-1
        
    }

}