算法初探——排序和查找

算法初探——排序和查找

冒泡排序

介绍：
冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
排序思想：

1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。
   动画演示：
   

代码实例：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {12, 56, 3, 78, 39};
 
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
 
        System.out.println(Arrays.toString(arr));
    }
}

插入排序

介绍：直接插入排序的基本操作是将一个记录插入到已经排好的有序表中，从而得到一个新的、记录数增1的有序表。对于给定的一组记录，初始时假定第一个记录自成一个有序序列，其余记录为无序序列。接着从第二个记录开始，按照记录的大小依次将当前处理的记录插入到其之前的有序序列中，直到最后一个记录插到有序序列中为止。
思想：从第二个位置开始插入，依次与该数据之前所有数据进行比较，数据比该数据大，数据往后顺移。否则该数据插入到第一个比该数据小的数据后面。
动画演示：

代码实例：

public class InsertSort {
    public static void insertSort(int[] a) {
        int i, j, insertNote;// 要插入的数据
        for (i = 1; i < a.length; i++) {// 从数组的第二个元素开始循环将数组中的元素插入
            insertNote = a[i];// 设置数组中的第2个元素为第一次循环要插入的数据
            j = i - 1;
            while (j >= 0 && insertNote < a[j]) {
                a[j + 1] = a[j];// 如果要插入的元素小于第j个元素,就将第j个元素向后移动
                j--;
            }
            a[j + 1] = insertNote;// 直到要插入的元素不小于第j个元素,将insertNote插入到数组中
        }
    }

    public static void main(String[] args) {
        int a[] = { 38,65,97,76,13,27,49 };
        insertSort(a);
        System.out.println(Arrays.toString(a));
    }
} 

选择排序

介绍：简单选择排序是最简单直观的一种算法，每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止，简单选择排序是不稳定排序。
思路：在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾
以此类推，直到所有元素均排序完毕
动画演示：

代码实例：

package sort;
 
public class SelectSort {
	public static void main(String[] args) {
		//模拟数据
		int[] array = {52,63,14,59,68,35,8,67,45,99};
		System.out.println("原数组：");
		for (int i : array) {
			System.out.print(i+" ");
		}
		System.out.println();
		selectSort(array);
		System.out.println("排序后：");
		for (int i : array) {
			System.out.print(i+" ");
		}
	}
	
	public static void selectSort(int[] arr){
		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]){
					min = j;
				}
			}
			if(min!=i){
				swap(arr, i, min);
			}
		}
	}
	//完成数组两元素间交换
	public static void swap(int[] arr,int a,int b){
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}
}

运行结果：

原数组：
52 63 14 59 68 35 8 67 45 99 
排序后：
8 14 35 45 52 59 63 67 68 99 

二分查找（折半查找）

二分查找

• 1.二分查找又称折半查找，它是一种效率较高的查找方法。
• 2.二分查找要求：（1）必须采用顺序存储结构 （2）.必须按关键字大小有序排列
• 3.原理：将数组分为三部分，依次是中值（所谓的中值就是数组中间位置的那个值）前，中值，中值后
• 将要查找的值和数组的中值进行比较，若小于中值则在中值前 面找，若大于中值则在中值后面找，
• 等于中值时直接返回。然后依次是一个递归过程，将前半部分或者后半部分继续分解为三部分

Arrays类的binary Search()方法，可以使用二分搜索法来搜索指定数组
binary Search()方法有两种参数类型：

1.binarySearch(Object[] a,Object key)

binarySearch(Object[] a,Object key)
a：要搜索的数组
key：要搜索的值
如果key包含在数组中，则返回搜索值的欧泽返回-1或“—”（插入点），插入点是搜索键将要插入数组的哪一点，即第一个大于此键的元素索引。

代码实例：

import java.util.Arrays;

public class Repeat {
	public static void main(String[] args) {
		int arr[] = new int[] {23,42,12,84,10};
		Arrays.sort(arr);
		int index = Arrays.binarySearch(arr, 84);
		System.out.println("84的索引位置："+index);
			
		}
	}

运行结果：

84的索引位置：4

2.binarySearch(Object[] a,int fromIndex,int toIndex,Object key)

语法格式：

binarySearch(Object[] a,int fromIndex,int toIndex,Object key)
a；要进行检索的数组
fromIndex：指定范围的开始处索引（包含）
toIndex： 指定范围的结束处索引（不包含）
key：要搜索的元素。

代码实例：

import java.util.Arrays;




public class Repeat {
	public static void main(String[] args) {
		//定义String型数组str
		String str[]=new String[] {"ab","cd","ef","gh"};
		Arrays.sort(str);
		//在指定的范围内搜索元素“cd”的索引位置
		int index = Arrays.binarySearch(str,0,2,"cd" );
		System.out.println("cd的索引位置："+index);
			
	}
}

运行结果：

cd的索引位置：1