数组

二维数组中的查找

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

从这个数组的右上角开始，即arr[0][len-1]
它左边的数都小于它，它下边的数都大于它
这样每次比较都可以排除一列或者一行

public class Solution {
    public boolean Find(int target, int [][] array) {
       
        return cut(target,0,array[0].length-1,array);
    }
    private boolean cut(int target,int row,int col,int[][] array){
        //如果超出了数组范围，说明找不到
        if(row>=array.length||col<0) return false;
        int find=array[row][col];
        if(target==find) return true;
        else if(target

---

旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

这道题用屁股就能想到O(n)的算法，遍历就完事了

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if(array.length==0) return 0; 
        //由于是非递减，所以第一个数就是最小的元素
        for(int i=1;i

用二分可以O(logn)的算法，边界判断很恶心

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if(array.length==0) return 0;
        int lo=0;
        int hi=array.length-1;
        while(loarray[hi])
                lo=mid+1;
           //如果最小值在左边9,10,1,2,3,4,5,6,7,8
           //这个mid相对于最小值偏右，作为原本的‘头部’，一定是小于原本的‘尾巴’
            else if(array[mid]

这里的hi--表明arr[lo]<=arr[mid]<=arr[hi]
相当于mid这个位置既在头部又在尾巴
也就是原数组刚好在重复值上旋转
比如1,0,1,1,1这种情况，二分中出现重复的值
只能递减，不能二分

---

调整数组顺序使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

首先是屁股算法O(n^2)
要保证稳定性，类似于冒泡排序，每当找到一个奇数，就把它往前推，即不停的和前一个偶数交换位置，这样每个奇数在移动到正确的位置的途中，并不会改变偶数的相对顺序

public class Solution {
    public void reOrderArray(int [] array) {
        int[] temp=new int[array.length];
        for(int i=0;i=0;j--)
                {
                    if(array[j]%2==1) break;
                    int tmp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=tmp;
                }
        }
    }
}

还可以用一个辅助数组，虽然不是原地排序，空间复杂度O(n)，但是时间复杂度也降到了O(n)

public class Solution {
    public void reOrderArray(int [] array) {
        int[] temp=new int[array.length];
        int pos=0;
        for(int i=0;i

---

连续子数组的最大和

HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)

和模板子序列和问题的唯一区别在如果全是负数需要取最小的一个，而不是不取

public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
        int now=0;
        int max=Integer.MIN_VALUE;//子序列的和可能为负
        for(int i:array){
            now+=i;
            if(now>max) max=now;
            if(now<0) now=0;
        }
        return max;
    }
}

---

把数组排成最小的数

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。

import java.util.Arrays;
import java.util.Comparator;
public class Solution {
    public String PrintMinNumber(int [] numbers) {
        if(numbers==null||numbers.length==0) return "";
        int N=numbers.length;
        String[] str=new String[N];
        for(int i=0;i() {
            @Override
            public int compare(String o1, String o2) {
                String s1=o1+""+o2;
                String s2=o2+""+o1;
                return s1.compareTo(s2);
            }
        });
        StringBuilder sb=new StringBuilder();
        for(String s:str){
            sb.append(s);
        }
        return sb.toString();
    }
}