数组问题

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

import java.util.ArrayList;
public class Solution {
    public void reOrderArray(int [] array) {
        //（1）方法一 冒泡交换
        /*for(int i=0;i<array.length;i++){
            for(int j=array.length-1;j>i;j--){
                if(array[j]%2!=0&&array[j-1]%2==0){
                    int temp=0;
                    temp=array[j];
                    array[j]=array[j-1];
                    array[j-1]=temp;
                }
            }
        }*/
        //方法（2）新建集合
        ArrayList<Integer> list=new ArrayList<>();
        ArrayList<Integer> list2=new ArrayList<>();
        for(int i=0;i<array.length;i++){
            if(array[i]%2==0){
                list.add(array[i]);
            }else{//存奇数
                list2.add(array[i]);
            }
        }
        for(int i=0;i<list2.size();i++){
            array[i]=list2.get(i);
        }
        for(int i=0;i<list.size();i++){
            array[i+list2.size()]=list.get(i);
        }
    }
}

2.{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和
分析：有可能不是从第一个元素开始计算，所以第二种解法存在双层的for循环

import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
        //第一种：单纯数组判别相加条件：元素正负
        if(array.length==0||array==null){
            return 0;
        }
        int []sum=new int [array.length];
        sum[0]=array[0];
        //判断是否相加
        for(int i=1;i<array.length;i++){
            sum[i] = (sum[i-1]<0?array[i]:sum[i-1]+array[i]);
        }
        int max=sum[0];
        for(int j=1;j<sum.length;j++){
            if(sum[j]>max){
                max=sum[j];
            }
        }
        return max;
        
        //第二种方法
        List<Integer> list=new ArrayList<>();
        for(int i=0;i<array.length;i++){
            int sum=0;//每次循环都要归0
            for(int j=i;j<array.length;j++){
                sum=sum+array[j];
                list.add(sum);
            }
        }
        if(list.size()==0){
            return 0;
        }
        Collections.sort(list);
        return list.get(list.size()-1);
    }
}

3.把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。

public class Solution {
    public int GetUglyNumber_Solution(int index) {
        if(index<=0) return 0;
        int [] arr=new int[index];
        int a2=0;
        int a3=0;
        int a5=0;
        arr[0]=1;
        int count=0;//计数
        int temp=0;//用来保存最小值
        while(count<index-1){
            //第一个数存在0索引  第index个存在index-1上
            temp=min(arr[a2]*2,arr[a3]*3,arr[a5]*5);
            if(temp==arr[a2]*2){a2++;}
            if(temp==arr[a3]*3){a3++;}
            if(temp==arr[a5]*5){a5++;}
            count++;
            arr[count]=temp;
        }
        return arr[index-1];
    }
    public int min(int a, int b, int c) {
        int temp = (a < b) ? a : b ;
        return temp < c ? temp : c ;
        }
}

4.

public boolean isContinuous(int [] numbers) {
        if(numbers.length<5){//排数小于5张肯定不是顺子
            return false;
        }
        //先排序
        Arrays.sort(numbers);
        //计算癞子数量
        int count=0;
        for(int i=0;i<numbers.length;i++){
            if(numbers[i]==0) {
                count++;
            }
        }
        //用癞子填补两个数字之间的差值
        for(int i=count;i<numbers.length-1;i++){
            //出现相同的数字肯定不是顺子
            if(numbers[i]==numbers[i+1]){
                return false;
            }
            //3和2之间不差数字   3-2-1
            count=count-(numbers[i+1]-numbers[i]-1);
        }
        if(count>=0){return true;}
        else{return false;}
    }

5.在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
分析：对于这种数组元素在 [0, n-1] 范围内的问题，可以将值为 i 的元素调整到第 i 个位置上进行求解。本题要求找出重复的数字，因此在调整过程中，如果第 i 位置上已经有一个值为 i 的元素，就可以知道 i 值重复

public boolean duplicate(int numbers[],int length,int [] duplication) {
        if(numbers==null||length<=0){
            return false;
        }
        for (int i = 0; i < length; i++) {
            while (numbers[i]!=i){
                if(numbers[i]==numbers[numbers[i]]){
                    duplication[0]=numbers[i];
                    return true;
                }
                swap(numbers,i,numbers[i]);
            }
        }
        return false;
    }
    public static void swap(int []num,int a,int b){
        int temp=num[a];
        num[a]=num[b];
        num[b]=temp;
    }

6.给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]…*A[i-1]A[i+1]…*A[n-1]。不能使用除法。（注意：规定B[0] = A[1] * A[2] * … * A[n-1]，B[n-1] = A[0] * A[1] * … * A[n-2];）

public int[] multiply(int[] A) {
    int n = A.length;
    int[] B = new int[n];
    for (int i = 0, product = 1; i < n; product *= A[i], i++)       /* 从左往右累乘 */
        B[i] = product;
    for (int i = n - 1, product = 1; i >= 0; product *= A[i], i--)  /* 从右往左累乘 */
        B[i] *= product;
    return B;

7.给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。
滑动窗口

 public ArrayList<Integer> maxInWindows(int [] num, int size)
    {
        //判断不成立的情况
        if(num==null||size<0){
            return null;
        }
        ArrayList<Integer> list=new ArrayList<>();
        if(size==0){
            return list;
        }
        if(num.length<size){
            return list;
        }else{
            for(int i=0;i<num.length-size+1;i++){
                //每个i值对应着一个区间 把这个区间放在一个集合中 
                ArrayList<Integer> temp=new ArrayList<>();
                for(int j=i;j<i+size;j++){
                    temp.add(num[j]);
                }
                //在每个集合中排序 选出最大的 添加到最终的list集合中
                Collections.sort(temp);//默认升序
                list.add(temp.get(temp.size()-1));
            }
        }
        return list;
    }