Java个人学习之旅(第五天)

数组的一些操作：

1.二分查找法：

要求:

1. 一定是有序的数组
2. 要有个中间数 ,即数组长度一定要大于1
3. 在查找的过程中，如果找到了，直接返回，没有找到，返回-1

代码示例:

import java.io.BufferedReader;
import java.io.InputStreamReader;

/**
 * 二分查找
 * @author Zireael
 *
 */

public class HalfSearch {
	public static void main(String[] args) throws Exception{
		
		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		
		//初始化一个有序数组
		int[] arr = new int[] {2,5,11,21,44,54,61,77,98};

		System.out.println("请输入要查找的数:");
		
		while(true) {
			//从键盘获取要查询的数字
			int num = Integer.parseInt(reader.readLine());
			
			int key = search(num,arr);
			
			if (key != -1) {
				System.out.println(num + " 的索引是" + key);
			}else {
				//如果返回值为-1,则显示没有这个数
				System.out.println("没有这个数");
			}
		}
	}
	
	public static int search(int num,int[] arr) {
		
		//定义数组起始下标
		int left = 0;
		//定义数组结尾下标
		int right = arr.length;
		
		//如果数组为空或者数组的长度小于1,则返回-1
		if (arr == null || arr.length < 1) {
			return -1;
		}else {
			while(left < right) {
				//定义中间下标
				int mid = (right + left)/2;
				
				if (arr[mid] == num) {
					//找到了就返回该下标
					return mid;
				}else if (arr[mid] > num) {
					//如果查询的元素小于中间下标对应的元素,则结尾下标自减
					right--;
				}else if (arr[mid] < num) {
					//如果查询的元素大于中间下标对应的元素,则起始下标自增
					left++;
				}
			}
		}	
		return -1;
	}
}

结果图:

当然,JDK本身就封装着一个方法来进行数组的二分查找,叫做binarySearch()

2.相关的一些算法：

2.1 冒泡排序

冒泡排序属于比较类排序算法
该算法会将数组的前一个元素与后一个元素作比较,如果前者大于后者则两者位置调换,直到该数组的元素为从小到大有序排列为止

最好(已经排序好了的数组)时间复杂度:O(n)
最坏时间复杂度:O(n²)
平均时间复杂度:O(n²)
空间复杂度:O(1)
稳定性:稳定

代码示例:

import java.util.Iterator;

/**
 * 冒泡排序
 * @author Zireael
 *
 */
public class BubblleSort {
	public static void main(String[] args) {
		//定义一个乱序的数组
		int[] arr = new int[] {-1,2,1,8,4,6,13,7,21,3,0};
		
		//调用排序方法
		int[] arr2 = sort(arr);
		
		//打印排序后的数组
		for (int i : arr2) {
			System.out.print(i);
			System.out.print(" ");
		}
	}
	
	public static int[] sort(int[] arr) {
		
		for(int i=1;i < arr.length;i++){
			boolean flag = true; //打个标记
			for(int j=0;j < arr.length - i;j++){
				if (arr[j] > arr[j+1]) {
					//如果数组的前一个数大于后一个数,则两个数的位置调换
					int tmp = arr[j+1]; 
					arr[j+1] = arr[j];
					arr[j] = tmp;
					
					flag = false;//一旦发现前一个数大于后一个数,则将标记改为false
				}
			}
			if (flag) {
				//一直到前一个数都小于后一个数为止
				break;
			}
		}
		return arr;
	}
}

运行结果图:

2.2 选择排序：

选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。
工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

最好时间复杂度:O(n²)
最坏时间复杂度:O(n²)
平均时间复杂度:O(n²)
空间复杂度:O(1)
稳定性:不稳定

代码示例:

/**
 * 选择排序
 * @author Zireael
 *
 */
public class SelectSort {
	public static void main(String[] args) {
		
		int[] arr= new int[] {5,2,1,-4,6,13,27,18};
		
		for(int i=0;i < arr.length - 1;i++){
			//假设一个最小值索引
			int min = i;
			for(int j=i+1;j < arr.length;j++){
				if (arr[j] < arr[min]) {
					//如果下标为j的索引对应的值小于最小值索引对应的值
					min = j; //将j赋值给min
				}
			}
			if (min != i) {
				//如果min不等于i,说明发现了更小的值,则调换索引位置
				int tmp = arr[i];
				arr[i] = arr[min];
				arr[min] = tmp;
			}
		}
		
		for (int i : arr) {
			System.out.print(i + " ");
		}
	}
}

2.3 快速排序

快速排序用到了分治思想，快速排序在划分子问题的时候经过多一步处理，将划分的两组数据划分为一大一小，划分的不定性使得快速排序的时间复杂度并不稳定。

快速排序的基本思想：通过一趟排序将待排序列分隔成独立的两部分，其中一部分记录的元素均比另一部分的元素小，则可分别对这两部分子序列继续进行排序，以达到整个序列有序。

最好时间复杂度:O(n * log n)
最坏时间复杂度:O(n * log n)
平均时间复杂度:O(n * log n)
空间复杂度:O(log n)
稳定性:不稳定

代码示例:

/**
 * 快速排序
 * @author Zireael
 *
 */
public class QuickSort {
	public static void main(String[] args) {
		
		int[] arr= new int[] {5,2,1,-4,6,13,27,18};
		
		if (arr.length == 0) {
			return;
		}else {
			quickSort(arr,0,arr.length-1);
		}
		
		for (int i : arr) {
			System.out.print(i + " ");
		}
		
	}
	
	
	public static void quickSort(int[] arr,int leftIndex,int rightIndex) {
		
		if (leftIndex > rightIndex) {
			return;
		}
		
		int i = leftIndex;
		int j = rightIndex;
		
		int p = arr[i];//确立一个基准值
		
		//结束循环的条件必定是i=j
		//将小于基准值的排在左边,将大于基准值的排在右边
		while(i < j) {
			
			//从右往左扫描
			if (arr[j] >= p) {
				j--;
			}
			
			arr[i] = arr[j];
			
			//从左往右扫描
			if (arr[i] <= p) {
				i++;
			}
			
			arr[j] = arr[i];
		}
		
		//基准归位,这样一来基准值就处于数组元素的中间了
		arr[i] = p;
		//排左边
		quickSort(arr, leftIndex, i - 1);
		//排右边
		quickSort(arr, j+1, rightIndex);
	}
}

运行结果:

3. 多维数组

多维数组就是数组的嵌套,即数组里的元素是更低维度的数组元素

二维数组定义方式:

dataType arrayName[length1][length2];

//例子
int[][] arr = new int[2][3];

因为纬度越高的数组,取数据和遍历的难度也就越大,所以一般只是用二维数组

参考文章
http://www.guoyaohua.com/