Java--冒泡、选择排序，二分查找

一、冒泡排序，选择排序，二分查找

package com.cat.stringbuffer;

public class BubbleSort {
	public static void main(String[] args) {
		//排序
		int[] array = {33,11,22,55,44};
		bubbleSort(array);//冒泡排序
		selectSort(array);//选择排序
		
		//二分查找
		int[] arr = {11,22,33,44,55,66,77,88};
		int i = binarySearch(arr,44);//二分查找
		System.out.print("二分查找索引：" + i);
	}

	//二分查找
	private static int binarySearch(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
				min = mid + 1;
			}else if(arr[mid] > value){   //中间值 > 指定要找值，最大索引 max  = mid - 1
				max = mid - 1;
			}
			
			mid = (min + max) / 2;
			if(min > max){
				return -1;
			}
		}
		return mid;
	}

	//选择排序
	public static void selectSort(int[] array) {
		/*
		 * 选择排序 
		 *     用一个索引位置上的元素，依次和其他索引位置上的元素比较，小的在前，打的在后
		 * 第一次：array[0]分别与array[1-4]比较4次
		 * 第二次：array[1]分别与array[2-4]比较3次
		 * 第三次：array[2]分别与array[3-4]比较2次
		 * 第四次：array[3]与array[4]比较1次
		 * */
		System.out.println();
		for (int i = 0; i < array.length - 1; i++) {  //外循环需要比较array.length - 1次
			for (int j = i+1 ; j < array.length; j++) {  
				if (array[i] > array[j]) {
					int temp = array[i];
					array[i] = array[j];
					array[j] = temp;
				}
			}
		}
		System.out.println("选择排序：");
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + " ");
		}
		System.out.println();
	}

	//冒泡排序
	public static void bubbleSort(int[] array) {
		/*
		 * 冒泡排序 
		 *     轻的上浮，沉的下降
		 *     两个相邻位置比较，如果前面的元素比后面的大就换位置
		 * 第一次：array[0]与array[1],array[1]与array[2],array[2]与array[3],array[3]与array[4]比较4次
		 * 第二次：array[0]与array[1],array[1]与array[2],array[2]与array[3]比较3次
		 * 第三次：array[0]与array[1],array[1]与array[2]比较2次
		 * 第四次：array[0]与array[1]比较1次
		 * */
		for (int i = 0; i < array.length - 1; i++) {  //外循环需要比较array.length - 1次
			for (int j = 0; j < array.length - 1 - i; j++) {  //-1防止数组越界，提高效率
				if (array[j] > array[j + 1]) {
					int temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
		System.out.println("冒泡排序：");
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + " ");
		}
	}
}

 

冒泡排序原理：

 

选择排序原理：

二分查找原理：

二、Java中有提供了一个Arrays类，JDK文档下解释如下：此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

1、Arrays类概述
          针对数组进行操作的工具类。
          提供了排序，查找等功能。

 2、成员方法
         [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.cat.stringbuffer;

import java.util.Arrays;

public class ArraysDemo {
	public static void main(String[] args) {
		/*Arrays类的概述和方法使用)
		  1、Arrays类概述
	         针对数组进行操作的工具类。
			 提供了排序，查找等功能。
		  2、成员方法
				[1]public static String toString(int[] a)
				[2]public static void sort(int[] a)
				[3]public static int binarySearch(int[] a,int key)
		 * */
		
		//数组转字符串
		int[] array = {33,11,22,55,44};
		System.out.println("数组转字符串：" + Arrays.toString(array));
		
		//排序
		Arrays.sort(array);
		System.out.println("排序：" + Arrays.toString(array));
		
		//二分查找
		int[] arr = {11,22,33,44,55,66,77};
		System.out.println("二分查找：" + Arrays.binarySearch(arr, 44));
		System.out.println("二分查找：" + Arrays.binarySearch(arr, 99));  //-插入点 - 1
	}
}