算法初探——排序和查找

冒泡排序

两两比较，找到最大值或者最小值的方式

1.大数上浮法

• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

例：

int[] arr = {13, 56, 22, 66, 25, 11, 30}
第一次 ——> 13,22,56,25,11,30,66
第二次 ——>13,22,25,11,30,56,66
第三次 ——>13,22,11,25,30,56,66
…

代码

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

2.小数下沉法

• 比较相邻的元素。如果第一个比第二个小，就交换他们两个。
• 对每一对相邻元素作同样的工作，从后面的第一对到最前面的一对。这步做完后，最前的元素会是最小的数。
• 针对所有的元素重复以上的步骤，除了最前一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

例：

int[] arr = {13, 56, 22, 66, 25, 11, 30}
第一次 ——> 11,13,56,22,66,25,30
第二次 ——>11,13,22,56,25,66,30
第三次 ——>11,13,22,25,56,30,66
…

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

选择排序

• 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
• 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
• 重复第二步，直到所有元素均排序完毕。

例

int[] arr = {13, 56, 22, 66, 25, 11, 30}
假设最小值为第一个值：13
将每个值与最小值比较，若比最小值小则赋值为最小值
第一次 ——>11,56,22,66,25,13,30
第二次 ——>11,13,22,66,25,56,30
第三次 ——>11,13,22,66,25,56,30
…

代码1

public static void getselect(double[] grade) {
		for (int i = 0; i < grade.length-1; i++) {
			int min = i;
			for (int j = i; j < grade.length; j++) {
				if (grade[min] > grade[j]) {
					min = j;
				}
			}
			if (min != i) {
				swap(grade,min,i);
			}
		}
	}
private static void swap(double[] grade, int j, int i) {
		grade[i] = grade[i] + grade[j];
		grade[j] = grade[i] - grade[j];
		grade[i] = grade[i] - grade[j];
		
	}	

代码2

private static void getsort(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);
				}
			}
		}
		
	}

	private static void swap(int[] arr, int i, int j) {
		arr[i] = arr[i] + arr[j];
		arr[j] = arr[i] - arr[j];
		arr[i] = arr[i] - arr[j];
		
	}

插入排序

对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

• 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
• 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

例：

int[] arr = {13, 56, 22, 25, 66, 11, 30}
第一次 ——>13,56,22,25,66,11,30
第二次 ——>13,22,56,25,66,11,30
第三次 ——>13,22,25,56,66,11,30
…

代码：

private static void getsort(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);
			}
		}
		
	}
	
	private static void swap(int[] arr, int i, int j) {
		arr[i] = arr[i] + arr[j];
		arr[j] = arr[i] - arr[j];
		arr[i] = arr[i] - arr[j];	
	}

二分查找

对于有序数列，才能使用二分查找法

如果我们要查找一元素，先看数组中间的值V和所需查找数据的大小关系，分三种情况：

1、等于所要查找的数据，直接找到
2、若小于 V，在小于 V 部分分组继续查询
2、若大于 V，在大于 V 部分分组继续查询

代码：

public static int find(Comparable[] arr, Comparable target) {
	    int l = 0, r = arr.length-1;
	    while( l <= r ){
	        int mid = l + (r-l)/2;

	        if( arr[mid].compareTo(target) == 0 ){
	               return mid;
	        }if( arr[mid].compareTo(target) > 0 ){
	                r = mid - 1;
	         } else{
	                l = mid + 1;
	         }
	    }
	    return -1;
}