查找
直接选择排序
直接选择排序是一种简单的排序算法。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置；再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
import java.util.Arrays;
public class SortTest {
public static void main(String[] args) {
// 定义需要升序排序的数组arr
int [] arr={
8,4,15,2,1};
// 对数组升序排序
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
// 找出第i个元素之后最小值的索引
for (int j = i + 1; j < arr.length; j++) {
if (arr[min] > arr[j]) {
min = j;
}
}
// 交换最小值
if (min != i) {
int tmp = arr[min];
arr[min] = arr[i];
arr[i] = tmp;
}
}
// 输出排序后的数组，使用java.util.Arrays包下的Arrays类调用toString方法可以打印数组元素
System.out.println(Arrays.toString(arr));
}
}
输出结果：
[1, 2, 4, 8, 15]
排序过程：
原始数组：8 4 15 2 1
第一次排序结果：1 8 4 15 2。排好了第1位。
第二次排序结果：1 2 8 4 15。排好了第2位。
第三次排序结果：1 2 4 8 15。排好了第3位。
第四次排序结果：1 2 4 8 15。排好了第4位。
冒泡排序
冒泡排序是一种简单的排序算法。它重复地走访要排序的数列，一次比较两个元素，如果他们的顺序（如从大到小、首字母从从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行，直到没有相邻元素需要交换。
import java.util.Arrays;
public class SortTest {
public static void main(String[] args) {
// 定义需要升序排序的数组arr
int [] arr={
8,4,15,2,1};
// 对数组升序排序
for(int i =1;i<arr.length;i++) {
// 依次对相邻两个元素排序，如果不符合排序规则，则调换他们的位置
for(int j=0;j<arr.length-i;j++) {
if(arr[j]>arr[j+1]) {
int temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
// 输出排序后的数组，使用java.util.Arrays包下的Arrays类调用toString方法可以打印数组元素
System.out.println(Arrays.toString(arr));
}
}
输出结果：
[1, 2, 4, 8, 15]
排序过程：
原始数组：8 4 15 2 1
第一次排序结果：4 8 2 1 15。排好了最后1位。
第二次排序结果：4 2 1 8 15。排好了倒数第2位。
第三次排序结果：2 1 4 8 15。排好了倒数第3位。
第四次排序结果：1 2 4 8 15。排好了倒数第4位。
直接选择排序和冒泡排序的优缺点
冒泡排序的优点是比较简单，空间复杂度较低，是稳定的；缺点是时间复杂度太高，效率慢。
选择排序的优点是一轮比较只需要换一次位置；缺点是效率慢，不稳定。
查找
顺序查找
顺序查找就是从数组的第一个元素开始，依次比较，直到找到目标数据或查找失败。
顺序查找举例：查找数组中是否存在值 432。
public class FindTest {
public static void main(String[] args) {
int i;
int[] arr={
1,2,4,5,54,321,867,432,3};
for( i=0;i<arr.length;i++){
// 顺序遍历数组中的值
// 判断是否存在元素432
if(arr[i]==432){
System.out.print("目标值的索引为："+i);
break;
}
if(i==arr.length-1){
System.out.println("数组中没有对应的值");
}
}
}
}
输出结果：
目标值的索引为：7
折半查找
能使用折半查找的前提是数组中的数据是有序的。
折半查找的原理：
假设查找的数组区间为 [min,max]，min 代表起始索引，max 代表结束索引，T 代表需要查找的值。
第一步：确定该区间的中间位置 K；
第二步：将查找的值 T 与 array[k] 比较。若相等，查找成功返回此位置；否则确定新的查找区域，继续折半查找；
第三步：若 array[k]>T，由数组的有序性可知 array[k,k+1,……,max] 中的每个值都大于 T，故新的区间为 array[min,……，K-1]，若 array[k]<T，同理可得新的查找区间为 array[k+1,……，max]。
每一次查找与中间值比较，可以确定是否查找成功，不成功的话下一次查找区间将缩小一半。
折半查找举例：查找数组中是否存在等于 80 的元素。
public static void main(String[] args) {
int [] arr={
5,13,19,21,37,56,64,75,80,88,92}; // 数组必须是有序的
// 定义三个变量分别记录最大、最小、中间的查找范围索引值
int max=arr.length-1;
int min=0;
int mid;
int target=21;
mid=(max+min)/2;
while(true) {
if(target<arr[mid]) {
// 如果目标元素小于中点元素
max = mid-1; // max向mid前移动
}
else if(target>arr[mid]) {
// 如果目标元素大于中点元素
min = mid+1; // min向mid后移动
}
else {
System.out.println(mid); // 找到目标元素
break;
}
if(max<min) {
// 没有找到的情况
System.out.println("没有找到");
break;
}
mid=(max+min)/2; // 重新计算中间索引值
}
}
执行结果：
3
顺序查找和折半查找
在查找速度方面，顺序查找自然是不及折半查找，我们代码中数组的长度比较小，没有太大差距，当数据量较大时，我们就能明显感觉到运行时间差距了。
从另一方面来说，顺序查找对数据要求不高，无需数据按照某种方式排列，也无需指定存储格式，顺序存储可以，链式存储也可以。所以从应用范围来说，顺序查找算法自然会更好。