算法知识梳理(4) 数组第一部分

1、概要

本文介绍了有关数组的算法第一部分的Java代码实现，全部代码都可经过 在线编译器 直接运行，算法目录：

• 二维数组的整数查找
• 旋转数组中的最小数字（旋转数组中的最大数字）
• 调整数组使奇数位于偶数以前
• 找出数组中出现次数超过一半的数字

2、代码实现

2.1 二维数组的整数查找

问题描述

在一个二维数组中，每一行都按照 从左到右递增的顺序，每一列都按照 从上到下递增的顺序 排序，编写一个函数，输入这样的一个二维数组和一个整数，判断该整数是否在二位数组中。

解决思路

首先要肯定整数存在于数组的一个 前提条件：若是最小的元素(左上角)大于d，或者最大的元素(右下角)小于d，那么能够肯定矩阵中不存在d。

这里须要关注一个特殊的点，二维数组右上角的元素d，若是以d所在的列将数组分为左右两个部分，那么 右边部分的全部元素都是大于d 的；而若是以d所在的行将数组分为上下两个部分，那么 上半部分的全部元素都是小于d 的。利用这一特性，咱们 从数组的右上角 开始搜寻：

• 判断数组右上角元素是否就是查找的值
• 若是不是，先按x轴的反方向遍历，从 右至左找到第一个不大于d 的元素。
• 以后再按y轴的正方向遍历，从 上至下找到第一个不小于d 的元素
• 通过以上两步，会获得一个缩小后的矩阵，检查前提条件是否仍然知足，若是不知足，那么就说明p不存在于数组中，反之则从第一步开始重复。

实现代码

class Untitled {

	static Boolean searchMisInt(int p[][], int d, int maxx, int maxy){
		int minx = 0; int miny = 0;
		while(minx <= maxx && miny <= maxy){
			//若是最小的元素(左上角)大于d，或者最大的元素(右下角)小于d，那么能够肯定矩阵中不存在p。
			if (p[minx][miny] > d|| p[maxx][maxy] < d)
				return false;
			//若是右上角的元素和p直接相等，那么直接返回。
			if (d == p[minx][maxy]) {
				return true;
			}
			//不断缩小矩形的范围。
			while (p[minx][maxy] > d) //从右上角的第一个元素，从右往左，找到第一个不大于d的元素。
				maxy -= 1;
			while (p[minx][maxy] < d) //从右上角的第一个元素，从上到下，找到第一个不小于d的元素。
				minx += 1;
		}
		return false;
	}
	public static void main(String[] args) {
		int p[][] = { {1, 2, 8, 9}, {2, 4, 9, 12}, {4, 7, 10, 13}, {6, 8, 11, 15}};
		System.out.println("result=" + searchMisInt(p, 10, 3, 3));
	}
}
复制代码

运行结果：

>> result=true
复制代码

2.2 得到旋转数组中的最小数字

问题描述

把一个数组最开始的若干个元素搬到数组的末尾，称为数组的旋转。如今输入一个递增序列的旋转数组，输出旋转数组的最小值，例如{1, 2, 3, 4, 5}的一个旋转数组为{3, 4, 5, 1, 2}，最小值为1。

解决思路

加入通过旋转后的数组不等于它自己，那么这个旋转后的数组有一个特色：它以最小值做为分界点被分为两个部分，不包含最小值的前半部分是有序的，包含最小值的后半部分也是有序的，所以咱们能够借助 二分查找 的思想。

首先得到当前数组的中点位置pMid：

• 若是pMid的数值 大于等于 首节点pStart的数值，那么说明 pMid 位于前半部分数组中，所以能够肯定最小值在[pMid, pEnd]之间
• 若是pMid的数值 小于等于 末节点pEnd的数值，那么说明 pMid 位于后半数组当中，而pMid是[pMid,pEnd]之间最小的元素，所以能够肯定最小值在[pStart, pMid]之间。
• 经过以上两步骤，不断缩小数组的范围，直到缩小后的数组只有两个元素为止，第二个元素的值就是咱们要找的最小值。

实现代码

class Untitled {

	static int rotateMinIndex(int p[], int length){
		if (length == 1) {
			return 0;
		}
		
		int pStart = 0;
		int pMid = 0;
		int pEnd = length-1;
		
		if (p[pStart] < p[pEnd]) {
			return pStart;
		}
		while (pStart < pEnd - 1) {
			pMid = (pStart + pEnd) >> 1;
			if (p[pStart] == p[pMid] && p[pMid] == p[pEnd])
				return rotateMinIndexOrder(p, pStart, pEnd);
			if (p[pMid] >= p[pStart]) //左边数组是有序的，最小点在右边
				pStart = pMid;
			else if(p[pMid] <= p[pEnd]) //右边数组是有序的，最小点在左边
				pEnd = pMid;
		}
		
		if (p[pStart] > p[pEnd])
			return p[pEnd];
		
		return -1;
	}

	static int rotateMinIndexOrder(int p[], int pStart, int pEnd){
		for(int i = pStart; i < pEnd; i++){
			if (p[i+1] < p[i])
				return i+1;
		}
		return pEnd;
	}

	public static void main(String[] args) {
		int p[] = {3, 4, 5, 1, 2};
		System.out.println("result=" + rotateMinIndex(p, 5));
	}
}
复制代码

运行结果

>> result=1
复制代码

2.3 调整数组使奇数位于偶数以前

问题描述

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得全部奇数位于数组的前半部分，全部偶数位于数组的后半部分。

解答思路

经过两个变量pStart、pEnd分别记录从首节点和末节点开始扫描的下标，pStart从首节点向末节点开始扫描，若是找到一个偶数，那么中止扫描，让pEnd从末节点向首节点开始扫描，直到找到一个奇数，而后和pStart所指向的偶数交换，这样就能保证[0, pStart]之间的都是奇数，而[pEnd, len-1]之间的都是偶数。

完成交换后，再开始移动pStart寻找下一个偶数，重复上面的操做，直到pStart和pEnd相遇，就能够知足问题的要求了。

实现代码

class Untitled {
	
	static void printArray(int p[]) {
		for (int i = 0; i < p.length; i++) {
			System.out.print(p[i] + ",");
		}
	}

	static void reverseOddEven(int p[], int length){
		int i = 0;
		int j = length-1;
		int t;
		while (true) {
			/*i指向数组length，或指向一个偶数*/
			while (i < length && p[i] % 2 != 0)
				i++;
			/*j指向-1，j指向一个奇数，j的值小于i*/
			while (j >= 0 && (p[j] % 2 == 0) && j >= i)
				j--;
			if (i > j)
				break;
			t = p[i]; p[i] = p[j]; p[j] = t;
		}
	}

	public static void main(String[] args) {
		int p[] = {3, 4, 5, 1, 2};
		reverseOddEven(p, p.length);
		printArray(p);
	}
}
复制代码

运行结果：

>> 3,1,5,4,2,
复制代码

2.4 找出数组中出现次数超过一半的数字

问题描述

找出数组中出现次数超过一半的数字

解决思路

将整个数组中的元素当作两类：出现次数超过一半的数字 和 其他数字。利用一个辅助的变量time和d，初始时候将d设为p[0]，time设为1，开始从头开始遍历数组。

实现代码

class Untitled {

	static Boolean verifyMoreThanHalf(int p[], int data, int length){
		int time = 0;
		for (int i = 0; i < length; i++) {
			if(p[i] == data)
				time++;
		}
		if ((time << 1) >= length)
			return true;
		return false;
	}

	static void moreThanHalf(int p[], int length) {
		//初始化
		int d = p[0];
		int time = 1;
		//从第二个元素开始遍历。
		for (int i = 1; i < length; i++) {
			if(time == 0){
				d = p[i];
				time = 1;
			}else if(d == p[i])
				time += 1;
			else
				time -= 1;
		}
		if (verifyMoreThanHalf(p, d, length)) {
			System.out.println("出现次数超过一半的元素=" + d);
		} else {
			System.out.println("没有次数超过一半的元素");
		}
		
	} 
	public static void main(String[] args) {
		int p[] = {1, 2, 3, 2, 2, -1, 2, 2, 8, 2, 2};
		moreThanHalf(p, p.length);
	}
}
复制代码

运行结果

>> 出现次数超过一半的元素=2
复制代码

---

更多文章，欢迎访问个人 Android 知识梳理系列：

• Android 知识梳理目录：www.jianshu.com/p/fd82d1899…
• 我的主页：lizejun.cn
• 我的知识总结目录：lizejun.cn/categories/