拼接最大值

package Leetcode;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Stack;

public class maxNum {
/**
 * 给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k <= m + n) 个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。
求满足该条件的最大数。结果返回一个表示该最大数的长度为 k 的数组。
 * @param args
 */

    public static void main(String[] args) {
        int []nums2={6,7};
        int []nums1={6,0,4};
        int []result=maxNumber(nums1, nums2, 5);
        int c=0;
    }
    //分成两个子数组分别留k1，k2个，之后merge找到merge最大值，保留k1，k2就是移除length1-k1,length2-k2,也就是扫描左边一个小于本身就pop出来，每次pop，length1-k1 减1，
    // 直到stack空或者移除完成，如果当前较小，就放进栈
    public static int[] maxNumber(int[] nums1, int[] nums2, int k) {
        if(k>nums1.length+nums2.length){
            return null;
        }
        int[] maxSubsequence = new int[k];
        Stack<Integer> s1=new Stack<>();
        Stack<Integer> s2=new Stack<>();
        List<Integer> list=new ArrayList<>();
        for(int i=0;i<=Math.min(k,nums1.length);i++){
            int j=k-i;
            if(j>nums2.length){
                continue;
            }
            
            int l=nums1.length-i;
            if(i!=0){
                s1.clear();
                for(Integer x:nums1){
                    while(l!=0&&(!s1.isEmpty())&&s1.peek()<x){
                        s1.pop();
                        l--;
                    }
                    s1.push(x);
                }
            }
            int p=nums2.length-j;
            if(j!=0){
                s2.clear();
                for(Integer x:nums2){
                    while(p!=0&&(!s2.isEmpty())&&s2.peek()<x){
                        s2.pop();
                        p--;
                    }
                    s2.push(x);
                }
            }
            int []l1=new int[s1.size()];
            int []l2=new int[s2.size()];
            if(!s1.isEmpty()){
                for(int x=l1.length-1;x>=0;x--){
                    l1[x]=s1.pop();
                }
            }
            if(!s2.isEmpty()){
                for(int x=l2.length-1;x>=0;x--){
                    l2[x]=s2.pop();
                }
            }
            
            int[] curMaxSubsequence = merge(l1, l2);
            if (compare(curMaxSubsequence, 0, maxSubsequence, 0) > 0) {
                System.arraycopy(curMaxSubsequence, 0, maxSubsequence, 0, k);
            }
            
        }

        
        return maxSubsequence;
    }

    public static int[] merge(int[] subsequence1, int[] subsequence2) {
        int x = subsequence1.length, y = subsequence2.length;
        if (x == 0) {
            return subsequence2;
        }
        if (y == 0) {
            return subsequence1;
        }
        int mergeLength = x + y;
        int[] merged = new int[mergeLength];
        int index1 = 0, index2 = 0;
        for (int i = 0; i < mergeLength; i++) {
            if (compare(subsequence1, index1, subsequence2, index2) > 0) {
                merged[i] = subsequence1[index1++];
            } else {
                merged[i] = subsequence2[index2++];
            }
        }
        return merged;
    }

    public static int compare(int[] subsequence1, int index1, int[] subsequence2, int index2) {
        int x = subsequence1.length, y = subsequence2.length;
        while (index1 < x && index2 < y) {
            int difference = subsequence1[index1] - subsequence2[index2];
            if (difference != 0) {
                return difference;
            }
            index1++;
            index2++;
        }
        return (x - index1) - (y - index2);
    }


    
}

package Leetcode;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Stack;

public class maxNum {

/**

 * 给定长度分别为 m 和 n 的两个数组，其元素由 0-9 构成，表示两个自然数各位上的数字。现在从这两个数组中选出 k (k <= m + n) 个数字拼接成一个新的数，要求从同一个数组中取出的数字保持其在原数组中的相对顺序。

求满足该条件的最大数。结果返回一个表示该最大数的长度为 k 的数组。

 * @param args

 */

    public static void main(String[] args) {

        int []nums2={6,7};

        int []nums1={6,0,4};

        int []result=maxNumber(nums1, nums2, 5);

        int c=0;

    }

    //分成两个子数组分别留k1，k2个，之后merge找到merge最大值，保留k1，k2就是移除length1-k1,length2-k2,也就是扫描左边一个小于本身就pop出来，每次pop，length1-k1 减1，

    // 直到stack空或者移除完成，如果当前较小，就放进栈

    public static int[] maxNumber(int[] nums1, int[] nums2, int k) {

        if(k>nums1.length+nums2.length){

            return null;

        }

        int[] maxSubsequence = new int[k];

        Stack<Integer> s1=new Stack<>();

        Stack<Integer> s2=new Stack<>();

        List<Integer> list=new ArrayList<>();

        for(int i=0;i<=Math.min(k,nums1.length);i++){

            int j=k-i;

            if(j>nums2.length){

                continue;

            }

            

            int l=nums1.length-i;

            if(i!=0){

                s1.clear();

                for(Integer x:nums1){

                    while(l!=0&&(!s1.isEmpty())&&s1.peek()<x){

                        s1.pop();

                        l--;

                    }

                    s1.push(x);

                }

            }

            int p=nums2.length-j;

            if(j!=0){

                s2.clear();

                for(Integer x:nums2){

                    while(p!=0&&(!s2.isEmpty())&&s2.peek()<x){

                        s2.pop();

                        p--;

                    }

                    s2.push(x);

                }

            }

            int []l1=new int[s1.size()];

            int []l2=new int[s2.size()];

            if(!s1.isEmpty()){

                for(int x=l1.length-1;x>=0;x--){

                    l1[x]=s1.pop();

                }

            }

            if(!s2.isEmpty()){

                for(int x=l2.length-1;x>=0;x--){

                    l2[x]=s2.pop();

                }

            }

            

            int[] curMaxSubsequence = merge(l1, l2);

            if (compare(curMaxSubsequence, 0, maxSubsequence, 0) > 0) {

                System.arraycopy(curMaxSubsequence, 0, maxSubsequence, 0, k);

            }

            

        }

        

        return maxSubsequence;

    }

    public static int[] merge(int[] subsequence1, int[] subsequence2) {

        int x = subsequence1.length, y = subsequence2.length;

        if (x == 0) {

            return subsequence2;

        }

        if (y == 0) {

            return subsequence1;

        }

        int mergeLength = x + y;

        int[] merged = new int[mergeLength];

        int index1 = 0, index2 = 0;

        for (int i = 0; i < mergeLength; i++) {

            if (compare(subsequence1, index1, subsequence2, index2) > 0) {

                merged[i] = subsequence1[index1++];

            } else {

                merged[i] = subsequence2[index2++];

            }

        }

        return merged;

    }

    public static int compare(int[] subsequence1, int index1, int[] subsequence2, int index2) {

        int x = subsequence1.length, y = subsequence2.length;

        while (index1 < x && index2 < y) {

            int difference = subsequence1[index1] - subsequence2[index2];

            if (difference != 0) {

                return difference;

            }

            index1++;

            index2++;

        }

        return (x - index1) - (y - index2);

    }

    

}