【蓝桥备战】快速排序+归并排序+二分查找 基本实现

快速排序

• 基本思路：首先设定一个pivot点，每次排序使pivot点左边的数都小于pivot；pivot点右边的数都大于pivot。 再使用左右递归，完成数组的排序。

pivot点可以是数组左边、右边、中间，或者任何一个位置。

• 具体实现：每次取数组最左边的值为pivot，使用两个指针i和j，分别从数组的左右两边移动。
  如果 i 指向的值大于pivot的同时， j 指向的值小于pivot，就交换 i 和 j 所指数字，否则移动 i 和 j点直到满足要求。最后将pivot和 j（因为当前的 j 一定指向小于pivot的值）交换位置。
• 算法实现：

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner (System.in);
		int n = s.nextInt();
		int [] arr = new int [n];
		for(int i = 0;i < n;i++) {
			arr[i] = s.nextInt();
		}
		sort(arr,0,n - 1);
		for(int i = 0;i < n;i++) {
			System.out.print(arr[i] + " "); 
		}
	}
	static void sort(int [] arr,int start,int end) {
		if(start >= end) return ;
		int p = partition(arr,start,end);
		sort(arr,start,p - 1);
		sort(arr,p + 1,end);
	}
	static int partition(int [] arr,int left,int right) {
		int pivot = arr[left];
		int i = left + 1,j = right;
		while(i <= j) {
			while(i < right && arr[i] <= pivot) {
				i ++;
			}
			while(j > left && arr[j] > pivot) {
				j --;
			}
			if(i >=j) break;
			swap(arr,i,j);
		}
		swap(arr,j,left);
		return j;
	}
	
	static void swap(int [] arr,int i,int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

归并排序

• 基本思路1：
  设定一个mid点，每次将mid点的左右两边进行递归拆分，最后把拆分的两个子数组合并。
• 基本思路2：
  也可以把归并排序抽象成二叉树的后序遍历。
  sort()方法即将数组向下拆分为一颗二叉树，可以理解为二叉树的遍历。
  merge()方法即在刚要离开一颗二叉树的节点时，将该节点的叶子节点合并。
• 算法实现：

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	static int [] temp;
	public static void main(String[] args) {
		Scanner s = new Scanner (System.in);
		int n = s.nextInt();
		int [] arr = new int [n];
		for(int i = 0;i<n;i++) {
			arr[i] = s.nextInt();
		}
		temp = new int [n];
		sort(arr,0,n - 1);
		for(int i = 0;i < n;i++) {
			System.out.print(arr[i] + " "); 
		}
	}
	static void sort(int [] arr ,int left,int right) {
		if(left >= right) return;
		int mid = left + (right - left) / 2;
		sort(arr,left,mid);
		sort(arr,mid + 1,right);
		megre(arr,left,mid,right);
		
	}
	static void megre(int [] arr,int left,int mid ,int right) {
		for(int i = left;i<= right;i++) {
			temp[i] = arr[i];
		}
		int i = left,j = mid + 1;
		int k = left;
		while(k <= right) {
			if(i > mid) {
				arr[k] = temp[j ++];
			}else if(j > right) {
				arr[k] = temp[i ++];
			}else if(temp[i] <= temp[j]) {
				arr[k] = temp[i ++];
			}else {
				arr[k] = temp[j ++];
			}
			k++;
		}
	}
}

二分查找

二分查找的思路简单，但我们最应该注意的是细节问题，然而所有的细节问题都可以用开闭区间来解释。

细节如下：

• 细节一：应该用while(left <= right) 还是while(left < right)。当定义right = nums.length - 1时，统一使用前者，也就是用<=。
• 细节二：right = mid 还是right = mid - 1。为了和 细节一 统一，我们使用后者。

原因如下：如果是left<=right，当left > right 时，并且right = mid- 1，退出循环，这样一次循环会全部包含区间内的内容，下一次循环也不会漏掉mid值。

• 算法实现：

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		int [] arr = new int [n];
		int num = s.nextInt();
		for(int i = 0;i<n;i++) {
			arr[i] = s.nextInt();
		}
		int [] target = new int [num];
		for(int i = 0;i<num;i++) {
			target[i] = s.nextInt();
		}
		for(int i = 0;i<num;i++) {
			int left = sort_left(arr, 0, n - 1,target[i]);
			int right = sort_right(arr, 0, n - 1,target[i]);
			if(left == -1 || right == -1) {
				System.out.println("-1 -1");
			}else {
				System.out.println(left + " "+ right);
			}
		}
	}
	//搜索左边界的二分查找
	static int sort_left(int [] arr,int left,int right,int target) {
		int mid;
		while(left <= right) {
			mid = left + (right - left) / 2;
			if(arr[mid] == target) {
				right = mid - 1;
			}else if(arr[mid] > target) {
				right = mid - 1;
			}else {
				left = mid + 1;
			}
		}
		if(left == arr.length) {
			return -1;
		}
		return arr[left] == target ? left : -1;
	}
	//搜索右边界的二分查找。
	static int sort_right(int [] arr,int left,int right,int target) {
		int mid;
		while(left <= right) {
			mid = left + (right - left) / 2;
			if(arr[mid] == target) {
				left = mid + 1;
			}else if(arr[mid] > target) {
				right = mid - 1;
			}else {
				left = mid + 1;
			}
		}
		if(right < 0) {
			return -1;
		}
		return arr[right] == target ? right : -1;
	}
}