数组常用操作

/**
* 需求: 数组的常用排序查找法
* 思路:
* 1. 新建一个公共类 ArrSort
* 2. 定义公共静态方法 xuanze maopao1 maopao2
* 3. 方法注释写过程
*/

public class ArrSort {
	/**
	* 主函数: 保证类文件的独立运行
	*/
	public static void main(String[] args) {
		// 定义初始数组
		int arrs[] = {-1, 20, 8, 99, 127, 423};
		//printArray(arrs);
		//xuanze(arrs);
		//printArray(arrs);
		//maopao1(arrs);
		//printArray(arrs);
		//maopao2(arrs);
		//printArray(arrs);
		//int[] arrs_sheng = {-1, 2, 3, 5, 78, 98, 119};
		System.out.println("要查找的元素的位置:" + chazhao(arrs, 20, false));
		int[] arrs_jiang = {119, 98, 76, 54, 32, 23, 10};
		System.out.println("要查找的元素的位置:" + chazhao(arrs_jiang, 18,true));
	}
	/**
	* 打印数组中的每个元素
	*/
	public static void printArray(int[] arrs) {
		if( arrs.length <=0 ) return; // 如果传入的数组为空则不进行处理
		System.out.print("["); //数组开始标志
		for(int i=0; i<arrs.length; i++) {
			// 保证格式, 因为length的是数组元素的个数,所以减1
			if(i != arrs.length-1) {
				System.out.print(arrs[i] + ",");
			} else {
				System.out.println(arrs[i] + "]");
			}
		}
	}
	/**
	* 实现交换两个元素
	*/
	private static void swap(int[] args, int x, int y) {
		if(args.length<=0 && x<0 && y<0) return;
		int temp = args[x];
		args[x] = args[y];
		args[y] = temp;
	}
	/**
	* 选择排序
	* 思路:
	* 1: 通过for循环对数组中的每个元素进行遍历
	* 2: 内层嵌套一个for循环,找到其中最大的元素
	* 3: 如果外层循环所代表的位置的元素小于内循环所代表的元素,使用临时变量进行交换
	* 4: 由于数组是引用传递所以不需要返回值
	*/
	public static void xuanze(int[] arrs) {
		// 判断数组是不是为空
		if(arrs.length <= 0) return;
		// 外层循环不需要对最后一个元素进行遍历
		for(int x=0, num=0, index=0; x<arrs.length-1; x++) {
			num = arrs[x];
			index = x;
			for(int y=x+1; y<arrs.length; y++) {
				if(num < arrs[y]) {
					num = arrs[y];
					index = y;
				}
			}
			if(index != x) swap(arrs, x, index);
		}
	}
	/**
	* 冒泡排序1
	* 思路:
	* 1: 使用外层循环控制内层循环的循环次数
	* 2: 内层循环依次比较两个相邻的两个元素,找出其中最小的进行交换
	*/
	public static void maopao1(int[] arrs) {
			if(arrs.length <=0) return;
			for(int x=0; x<arrs.length-1; x++) {
				//-x 因为x是控制内循环次数的
				for(int y=0; y< arrs.length-1-x; y++) {
					if(arrs[y] > arrs[y+1]) {
						swap(arrs, y, y+1);
					}
				}
			}
	}
	/**
	* 冒泡排序2
	* 同冒泡1的思路 只不过外层循环是由最后索引来进行递减
	*/
	public static void maopao2(int[] arrs) {
		if(arrs.length <=0) return;
		for(int x=arrs.length; x>0; x--) {
			for(int y=0; y<x-1; y++) {
				//System.out.println("X=" + x + " arrs[y]=" + arrs[y] + " arrs[y+1]=" + arrs[y+1]);
				if(arrs[y] < arrs[y+1]) {
					swap(arrs, y, y+1);
				}
			}
		}
		
	}

	/**
	* 折半查找
	* 思路:
	* 1.定义3个变量 min最小下标位置 mid中间位置 max最大下表位置
	* 2.判断数组是升序还是降序
	* 3.升序处理思路
	* 4.降序处理思路
	* 有序如果没有该元素返回插入点
	*/
	public static int chazhao(int[] arrs, int key, boolean isYouXu) {
		if(isYouXu) {
			if(arrs.length <= 0) return -1;
			int min=0, max=arrs.length-1, mid=(min+max)>>1;
			System.out.println(arrs[max] > arrs[min]);
			if(arrs[max] > arrs[min]) { // 升序
				// 升序思路: 循环判断key是不是不等于 arrs[mid]
				while(key != arrs[mid]) {
					if(key > arrs[mid]) { // 要查找的元素比mid下标所在元素大
						// 移动最小下标
						min = mid+1;
					} else if(key < arrs[mid]){ //要查找的元素比mid下表所在元素小
						// 移动最大下标
						max = mid-1;
					} 
					// 判断最大下标是不是小于最小下标
					if(max < min) return -min-1; // 没有查找到元素
					mid = (min+max)/2;
				}
				return mid; // 循环结束,证明找到了该元素返回位置
			} else { // 降序
				System.out.println("进入降序查找");
				// 降序思路
				// 判断max<=min // 如果成立就返回-1 证明没有查找到元素	
				while(max >= min) {
					mid = (min+max)>>1; // 右移一位相当于除2
					System.out.println("MAX=" + max + " Min=" + min + " Mid=" + mid);
					if(key > arrs[mid]) { // 要查找的元素比mid所在元素大,移动max
						max = mid-1;
					} else if(key < arrs[mid]){ //要查找的元素比mid所在元素小,移动min
						min = mid+1;
					} else { // 要查找的元素即不大于mid所在元素也不小于 那么就只有等于了 所以直接返回 mid
						return mid;
					}
				}
				return -min+1;
			}
		} else { // 无序的查找
			for(int i=0; i<arrs.length; i++) {
				if(key == arrs[i]) return i;
			}
			return -1;
		}
	}
}