2019-06-13 java学习日记

Posted 2022-01-07 sherwin-liao

冒泡排序

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

 1 //冒泡排序
 2     public static void main(String[] args) 
 3         int[] arr = 32, 44, 55, 65, 11;
 4         bubble(arr);
 5         print(arr);
 6     
 7         
 8     
 9 
10 
11     private static void bubble(int[] arr) 
12         //外循环只需要比较数组的长度-1次
13         for (int i = 0; i < arr.length - 1; i++) 
14         //内循环 -1是为了防止索引越界，-i是为了提高效率
15             for (int j = 0; j < arr.length - 1 - i; j++) 
16                 //这里这个大于小于是决定他是从大到小还是从小到大
17                 if (arr[j] > arr[j + 1]) 
18                     int a = arr[j];
19                     arr[j] = arr[j + 1];
20                     arr[j + 1] = a;
21                 
22             
23             
24         
25     
26     //打印
27     private static void print(int[] arr) 
28         for (int i = 0; i < arr.length; i++) 
29             System.out.print(arr[i] + " ");
30         
31     

 

 

 

选择排序

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

 1 public static void main(String[] args) 
 2         int[] arr = 32, 44, 55, 65, 11;
 3         bubble(arr);
 4 //      select(arr);
 5         print(arr);
 6     
 7     /**
 8      * 选择排序
 9      * 1、返回值类型void
10      * 2、参数列表int[] arr
11      */
12     public static void selectSort(int[] arr) 
13       //只需要比较arr.length-1次
14         for (int i = 0; i < arr.length - 1; i++)       
15             for (int j = i + 1; j < arr.length; j++) 
16                 if (arr[i] > arr[j]) 
17                  /*int temp = arr[i];
18                     arr[i] = arr[j];
19                     arr[j] = temp;    */
20                     swap(arr, i, j);
21                 
22             
23         
24     
25     /**
26      * 打印数组
27      * 1、返回值类型void
28      * 2、参数列表int[] arr
29      */
30     public static void print(int[] arr) 
31         for (int i = 0; i < arr.length; i++) 
32             System.out.print(arr[i] + " ");
33         
34     
35     /**
36      * 换位操作
37      * 1、返回值类型，void
38      * 2、参数列表int[] arr.int i,int j
39      * 
40      * 如果某个方法,只针对本类使用,不想让其他类使用就可以定义成私有的
41      */
42     private static void swap(int[] arr,int i,int j) 
43         int temp = arr[i];
44         arr[i] = arr[j];
45         arr[j] = temp;
46     
47 

 

 

 

二分查找

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

 1 public static void main(String[] args) 
 2             int[] arr = 11,22,33,44,55,66,77;
 3             System.out.println(getIndex(arr, 22));
 4             System.out.println(getIndex(arr, 66));
 5             System.out.println(getIndex(arr, 88));
 6         
 7         /**
 8          * 二分查找
 9          * 1、返回值类型int
10          * 2、参数列表int[] arr,int value
11          * 
12          */
13         public static int getIndex(int[] arr, int value) 
14             int min = 0;
15             int max = arr.length - 1;
16             int mid = (min + max) / 2;
17            //当中间值不等于要找的值,就开始循环查找
18             while (arr[mid] != value)      
19            //当中间值小于了要找的值
20                 if (arr[mid] < value)      
21            //最小的索引改变
22                     min = mid + 1;              
23            //当中间值大于了要找的值
24                 else if (arr[mid] > value)    
25            //最大的索引改变
26                     max = mid - 1;               
27                 
28            //无论最大还是最小改变,中间索引随之改变     
29                 mid = (min + max) / 2;           
30            //如果最小索引大于了最大索引,就没有查找的可能性了     
31                 if (min > max)             
32            //返回-1           
33                     return -1;                    
34                 
35             
36             return mid;
37         

 

 

 

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