android 求数组最大值,面试算法知识梳理(7) - 数组第四部分

面试算法代码知识梳理系列

一、概要

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

求数组当中的最长递增子序列(求数组当中的最长递减子序列)

区间重合判断

一个整数数组，长度为n，将其分为m份，使各份的和相等，求m的最大值

二、代码实现

2.1 求数组当中的最长递增子序列

代码实现

class Untitled {

//查找最长递增子序列。

static void searchMaxIncSubArray(int p[], int length) {

//maxValue[i]表示长度为i的递增子序列的最大元素的最小值。

int[] maxValue = new int[length+1];

maxValue[1] = p[0];

int k=1;

for (int i=1; i

if (p[i] > maxValue[k]) {

k++;

maxValue[k] = p[i];

} else if (p[i] == maxValue[k]) { //如果p[i]和maxValue[k]，那么越过。

continue;

} else { //如果p[i]小于maxValue[k]。

if (p[i] < maxValue[1]) {

maxValue[1] = p[i];

continue;

}

int first = 1;

int last = k;

//二分查找：目的是在maxValue数组中找到大于p[i]的第一个元素，如果它大于p[i]，那么就替换它。

while (first < last) {

int mid = (last-first) >> 1;

if (maxValue[first+mid] < p[i]) {

first=first+mid+1;

} else if (maxValue[first+mid] > p[i]) {

last=first+mid;

} else {

first=first+mid+1;

}

}

//进行替换。

if (p[i] < maxValue[first]) {

p[i] = maxValue[first];

}

}

}

System.out.println("k=" + k);

}

public static void main(String[] args) {

int[] p = {1,2,31,4,20,-7,8};

searchMaxIncSubArray(p, p.length);

}

}

运行结果

>> k=3

2.2 区间重合判断

代码实现

class Untitled {

static class Area {

int start;

int end;

Area(int start, int end) {

this.start = start;

this.end = end;

}

}

//首先对区间进行排序，按照start进行递增排序。

static void sortArea(Area areas[], int start, int end) {

if (start==end) {

return;

}

int mid = start;

Area midValue = areas[start];

for (int i=start+1; i<=end; i++) {

Area data = areas[i];

if (data.start < midValue.start) {

mid++;

areas[i] = areas[mid];

areas[mid] = data;

}

}

Area temp = areas[mid];

areas[mid] = areas[start];

areas[start] = temp;

if (mid > start) {

sortArea(areas, start, mid-1);

}

if (mid < end) {

sortArea(areas, mid+1, end);

}

}

//合并区间，使得两个区间之间互不重合。

static int mergeArea(Area areas[], int len) {

int lastIndex = 0;

Area lastArea = areas[0];

for (int i=1; i

Area cur = areas[i];

if (cur.start <= lastArea.end) {

if (cur.end > lastArea.end) {

lastArea.end = cur.end;

areas[lastIndex] = lastArea;

}

} else {

lastArea = cur;

lastIndex++;

areas[lastIndex] = lastArea;

}

}

return lastIndex+1;

}

//通过二分查找，确定目标区间是否在其范围之内。

static boolean searchArea(Area areas[], int areasLen, Area target) {

int startIndex = 0;

int endIndex = areasLen-1;

while (startIndex <= endIndex) {

int mid = (startIndex+endIndex) >> 1;

Area midValue = areas[mid];

if (target.start < midValue.start) {

if (target.end > midValue.end) {

return false;

} else {

endIndex=mid-1;

}

} else if (target.start >= midValue.start && target.start <= midValue.end) {

if (target.end <= midValue.end) {

return true;

} else {

return false;

}

} else {

startIndex = mid+1;

}

}

return false;

}

static void printArea(Area areas[], int len) {

for (int i=0; i

Area area = areas[i];

System.out.println("start=" + area.start + ",end=" + area.end);

}

}

public static void main(String[] args) {

Area areas[] = new Area[] {

new Area(1, 3),

new Area(5, 9),

new Area(2, 4),

new Area(10, 11),

};

sortArea(areas, 0, areas.length-1);

System.out.println("- 排序结果 -");

printArea(areas, areas.length);

int mergeLen = mergeArea(areas, areas.length);

System.out.println("- 合并结果 -");

printArea(areas, mergeLen);

Area target = new Area(3, 4);

System.out.println("处于区间内=" + searchArea(areas, mergeLen, target));

}

}

运行结果

>> - 排序结果 -

>> start=1,end=3

>> start=2,end=4

>> start=5,end=9

>> start=10,end=11

>> - 合并结果 -

>> start=1,end=4

>> start=5,end=9

>> start=10,end=11

>> 处于区间内=true

2.3 一个整数数组，长度为 n，将其分为 m 份，使各份的和相等，求 m 的最大值

代码实现

class Untitled {

static Boolean testGroup(int p[], int aux[], int pLen, int groupLen, int curSum, int groupSum, int groupID){

if (curSum < 0)

return false;

if (curSum == 0){

groupID++;

curSum = groupSum;

if (groupID == groupLen+1) {

return true;

}

}

for (int i=0; i

if (aux[i] != 0) {

continue;

}

aux[i] = groupID;

if (testGroup(p, aux, pLen, groupLen, curSum-p[i], groupSum, groupID)) {

return true;

}

aux[i] = 0;

}

return false;

}

static void maxGroup(int p[], int len) {

int aux[] = new int[len];

int sum = 0;

for (int i=0; i

aux[i] = 0;

sum += p[i];

}

for (int m=len; m>=2; m--) {

if (sum%m != 0) {

continue;

}

if (testGroup(p, aux, len, m, sum/m, sum/m, 1)) {

System.out.println("m=" + m);

for (int i=0; i

System.out.println("aux[" + i + "]=" + aux[i]);

}

}

}

}

public static void main(String[] args) {

int a[] = {3,2,4,3,6};

maxGroup(a, a.length);

}

}

运行结果

>> m=3

>> aux[0]=1

>> aux[1]=2

>> aux[2]=2

>> aux[3]=1

>> aux[4]=3

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