|
21 | 21 | */ |
22 | 22 | public class MaxNumberFromTwoArray { |
23 | 23 | public int[] maxNumber(int[] nums1, int[] nums2, int k) { |
24 | | - |
25 | | - int[] result = new int[k]; |
26 | | - //try k from nums1 and k - i from nums2. |
27 | | - //Combine then by merge sort routine. And see that this result is bigger than |
28 | | - //already stored result. If yes then store it as result. |
29 | | - for (int i = 0; i <= nums1.length; i++) { |
30 | | - |
31 | | - if (k - i < 0 || i > nums1.length || (k - i) > nums2.length) { |
| 24 | + int[] max = new int[k]; |
| 25 | + for (int i = 0; i <= k; i++) { |
| 26 | + if (nums1.length < i || nums2.length < k - i) { |
32 | 27 | continue; |
33 | 28 | } |
34 | | - |
35 | | - int[] r1 = findMaxNumber(nums1, i); |
36 | | - int[] r2 = findMaxNumber(nums2, k - i); |
37 | | - |
38 | | - int x = 0, y = 0; |
39 | | - int r[] = new int[k]; |
40 | | - int index = 0; |
41 | | - while (x < r1.length && y < r2.length) { |
42 | | - //if both the numbers are equal then keep check till the end to see which one has greater |
43 | | - //number following after current number. |
44 | | - if (r1[x] == r2[y]) { |
45 | | - int t = x + 1; |
46 | | - int u = y + 1; |
47 | | - while (t < r1.length && u < r2.length) { |
48 | | - if (r1[t] == r2[u]) { |
49 | | - t++; |
50 | | - u++; |
51 | | - } else { |
52 | | - break; |
53 | | - } |
54 | | - } |
55 | | - if (t == r1.length || u == r2.length) { |
56 | | - r[index++] = (t == r1.length ? r2[y++] : r1[x++]); |
57 | | - } else { |
58 | | - r[index++] = r1[t] > r2[u] ? r1[x++] : r2[y++]; |
59 | | - } |
60 | | - } else if (r1[x] > r2[y]) { |
61 | | - r[index++] = r1[x++]; |
62 | | - } else if (r2[y] > r1[x]) { |
63 | | - r[index++] = r2[y++]; |
64 | | - } |
65 | | - } |
66 | | - |
67 | | - while (x < r1.length) { |
68 | | - r[index++] = r1[x++]; |
69 | | - } |
70 | | - |
71 | | - while(y < r2.length) { |
72 | | - r[index++] = r2[y++]; |
| 29 | + int[] a = merge(findLargest1(nums1, i), findLargest1(nums2, k - i)); |
| 30 | + if (isGreater(a, max, 0, 0)) { |
| 31 | + max = a; |
73 | 32 | } |
| 33 | + } |
| 34 | + return max; |
| 35 | + } |
74 | 36 |
|
75 | | - if (isBigger(r, result)) { |
76 | | - result = r; |
| 37 | + private int[] merge(int[] a1, int[] a2) { |
| 38 | + int[] result = new int[a1.length + a2.length]; |
| 39 | + int i = 0; |
| 40 | + int j = 0; |
| 41 | + int k = 0; |
| 42 | + while (i < a1.length || j < a2.length) { |
| 43 | + if (i == a1.length) { |
| 44 | + result[k++] = a2[j++]; |
| 45 | + } else if (j == a2.length) { |
| 46 | + result[k++] = a1[i++]; |
| 47 | + } else if (a1[i] > a2[j]) { |
| 48 | + result[k++] = a1[i++]; |
| 49 | + } else if (a1[i] < a2[j]) { |
| 50 | + result[k++] = a2[j++]; |
| 51 | + } else { |
| 52 | + if (isGreater(a1, a2, i, j)) { |
| 53 | + result[k++] = a1[i++]; |
| 54 | + } else { |
| 55 | + result[k++] = a2[j++]; |
| 56 | + } |
77 | 57 | } |
78 | 58 | } |
79 | | - |
80 | 59 | return result; |
81 | 60 | } |
82 | 61 |
|
83 | | - private boolean isBigger(int[] r1, int[] r2) { |
84 | | - for (inti = 0; i < r1.length; i++) { |
85 | | - if (r1[i] > r2[i]) { |
| 62 | + private boolean isGreater(int[] a, int[] b, inti, intj) { |
| 63 | + while (i < a.length && j < b.length) { |
| 64 | + if (a[i] > b[j]) { |
86 | 65 | return true; |
87 | | - } else if (r1[i] < r2[i]) { |
| 66 | + } else if (a[i] < b[j]) { |
88 | 67 | return false; |
89 | 68 | } |
| 69 | + i++; |
| 70 | + j++; |
90 | 71 | } |
91 | | - return false; |
| 72 | + return j == b.length; |
92 | 73 | } |
93 | 74 |
|
94 | | - /** |
95 | | - * Find max number by removing k digits from input. |
96 | | - */ |
97 | | - private int[] findMaxNumber(int input[],int k) { |
98 | | - int remaining = input.length - k; |
99 | | - Deque<Integer> stack = new LinkedList<>(); |
100 | | - for (int i = 0; i < input.length; i++) { |
101 | | - while(!stack.isEmpty() && remaining > 0) { |
102 | | - if (stack.peek() < input[i]) { |
103 | | - stack.pollFirst(); |
104 | | - remaining--; |
105 | | - } else { |
106 | | - break; |
107 | | - } |
108 | | - } |
109 | | - stack.offerFirst(input[i]); |
| 75 | + private int[] findLargest1(int[] nums, int k) { |
| 76 | + if (k == 0) { |
| 77 | + return new int[0]; |
110 | 78 | } |
111 | | - int[] result = new int[Math.min(k, input.length)]; |
112 | | - for (int i = 0; i < result.length; i++) { |
113 | | - result[i] = stack.pollLast(); |
| 79 | + int[] result = new int[k]; |
| 80 | + int index = 0; |
| 81 | + for (int i = 0; i < nums.length; i++) { |
| 82 | + while (index > 0 && index + (nums.length - i - 1) >= k && result[index - 1] < nums[i]) { |
| 83 | + index--; |
| 84 | + } |
| 85 | + if (index < k) { |
| 86 | + result[index++] = nums[i]; |
| 87 | + } |
114 | 88 | } |
115 | | - |
116 | 89 | return result; |
117 | 90 | } |
118 | 91 |
|
|
0 commit comments