算法初探 —— 排序 & 查找 & Arrays类

一.排序

冒泡排序：（两种）基于大数上浮法;基于小数下沉法
两两比较，找到最大值或者最小值的方式
选择排序：（两种）
每次找到最小值，将它交换到对应的位置（第一位）
插入排序：
默认第一个是有序的，第二个开始，向有序进行插入

1.1冒泡排序

1.上浮法（每次找max跑到最后面）和下沉法（每次找min跑到最前面）并不是升序和降序排列
2.N个数，N-1轮，每轮比较N-1-i次
3.两两比较，找到最大值或者最小值的方式

以下例题以升序为例：

package com.openlab.HW08.sort;

public class BubbleSort {

	public static void main(String[] args) {
		int[] arr = {5,7,6,2,8};
		
		//		bubbleSort(arr);
//		bubbleSort02(arr);
		
//		selectSort(arr);
//		selectSort02(arr);
		
		insertSort(arr);
		
		for(int i=1;i<arr.length;i++) {
			System.out.print(arr[i]);
		}
	}
	
	//冒泡排序，基于大数上浮法
	public static void bubbleSort(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]) {
					swap(arr,j,j+1);
				}
				
			}
		}
	//冒泡排序,基于小数下沉法

	public static void bubbleSort(int[] arr) {
		for(int i=0;i<arr.length-1;i++) {
			
			for(int j=arr.length -1;j >i ;j--) {
				if(arr[j]<arr[j-1]) {
					swap(arr,j,j-1);
				}
				
			}
		}
		
	}
		

}
	
	//交换方法一：add  m=j  n =j+1
	private static void swap(int[] arr, int m, int n) {
		arr[m] = arr[m] + arr[n];
		arr[n] = arr[m] - arr[n];
		arr[m] = arr[m] - arr[n];
	}
	//交换方法二： temp
	/**int tmp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = tmp;
     **/
 
	
}

1.2选择排序

每次找到最小值，将它交换到对应的位置（第一位）
N个数，N-1轮，N-i次

// 选择排序
	public static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			int min = i;
			for (int j = i; j < arr.length; j++) {
				if (arr[min] > arr[j]) {
					min = j;
				}
			}
			if (min != i) {
				swap(arr, i, min);
			}
		}
	}
// 选择排序的变种，也可以认为是选择排序
	public static void selectSort02(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i; j < arr.length; j++) {
				if (arr[i] > arr[j]) {
					swap(arr, i, j);
				}
			}
		}
	}

1.3插入排序

321
i=1
j=1>0 arr[1]=2<arr[0]=3 换 231 j–=0
i=2
j=2>0 arr[2]=1<arr[1]=3 换 213 j–=1>0
arr[1]=1<arr[0]=2 换 123 j–=0 !> 0 跳出内循环
所以123

// 插入排序
	public static void insertSort(int[] arr) {
		for (int i = 1; i < arr.length; i++) {
			for (int j = i; j > 0 && arr[j] < arr[j - 1] ; j--) {
				swap(arr, j, j - 1);
			}
		}
	}

二.查找

查询算法：
二分查找（折半查找）
如果查询数据是无序的，那就找线性（遍历）查找

package com.openlab.day08.sort;

public class TestSearch {

	public static void main(String[] args) {
		int[] arr = {1, 2, 9, -100, -55, 23, -99, 0, 3, 4, 8};
		TestSort.bubbleSort(arr);
		
//		int index = linearSearch(arr, 23);
		
		int index = binarySearch(arr, -999);
		System.out.println(index);
	}

	// 线性查找，可以查询，但是效率较低，随着数据越来越多
	public static int linearSearch(int[] arr, int key) {
		for (int i = 0; i < arr.length; i++) {
			if (key == arr[i]) {
				return i;
			}
		}
		return -1;
	}
	
	// 二分查找，又被叫做折半查找
	public static int binarySearch(int[] arr, int key) {
		int start = 0;
		int end = arr.length - 1;
		
		while (start <= end) {
			// 注意，需要将中间值的下标重新计算
			int middle = (start + end) / 2;
			if (arr[middle] > key) {
				end = middle - 1;
			} else if (arr[middle] < key) {
				start = middle + 1;
			} else {
				return middle;
			}
		}
		return -1;
	}
	
}

三.Arrays类的学习和使用：

数组（array）:
Arrays是java提供一个工具类，主要用来操作和使用数组。

java.util.Arrays

package com.openlab.day08.sort;

import java.util.Arrays;

public class TestArrays {
	public static void main(String[] args) {
		
//		int[] arr = {1, 2, 9, -100, -55, 23, -99, 0, 3, 4, 8};
//		Arrays.sort(arr);
//		// 底层使用的快速排序
//		for (int i : arr) {
//			System.out.print(i + ",");
//		}
		
//		int index = Arrays.binarySearch(arr, -99);
//		System.out.println(index);
		
		int[] arr = new int[10];
		Arrays.fill(arr, 10);
		for (int i : arr) {
			System.out.print(i + ",");
		}
		System.out.println();
		
		int[] newArr = Arrays.copyOf(arr, arr.length);
		for (int i : newArr) {
			System.out.print(i + ",");
		}
	}
	
}