मैं साझा करना चाहूंगा कि मैंने कैसे सोचा कि समाधान ... मैंने समाधान को देखा जिसमें पुनरावृत्ति शामिल है और वे बहुत अद्भुत हैं, अच्छी तरह से कार्यात्मक और मॉड्यूलर सोच का परिणाम है। मैं वास्तव में साझा करने की सराहना करता हूं।
मैं यह जोड़ना चाहूंगा कि बड़े lits के लिए रिकर्सन काम नहीं करेगा, स्टैक कॉल ओवरफ्लो होगा; इसलिए मैंने पुनरावृत्ति दृष्टिकोण की कोशिश करने का फैसला किया ... और यही मुझे मिलता है।
कोड बहुत आत्म व्याख्यात्मक है, मैंने इसको आश्वस्त करने के लिए कुछ इनलाइन टिप्पणियाँ जोड़ीं।
यदि आपको यह नहीं मिलता है, तो कृपया मुझे सूचित करें और मैं पठनीयता में सुधार करूंगा (शायद मुझे अपने कोड की भ्रामक व्याख्या हो रही है)।
import java.util.Random;
public class Solution {
public static class Node<T extends Comparable<? super T>> implements Comparable<Node<T>> {
T data;
Node next;
@Override
public int compareTo(Node<T> otherNode) {
return data.compareTo(otherNode.data);
}
@Override
public String toString() {
return ((data != null) ? data.toString() + ((next != null) ? "," + next.toString() : "") : "null");
}
}
public static Node merge(Node firstLeft, Node firstRight) {
combine(firstLeft, firstRight);
return Comparision.perform(firstLeft, firstRight).min;
}
private static void combine(Node leftNode, Node rightNode) {
while (leftNode != null && rightNode != null) {
// get comparision data about "current pair of nodes being analized".
Comparision comparision = Comparision.perform(leftNode, rightNode);
// stores references to the next nodes
Node nextLeft = leftNode.next;
Node nextRight = rightNode.next;
// set the "next node" of the "minor node" between the "current pair of nodes being analized"...
// ...to be equals the minor node between the "major node" and "the next one of the minor node" of the former comparision.
comparision.min.next = Comparision.perform(comparision.max, comparision.min.next).min;
if (comparision.min == leftNode) {
leftNode = nextLeft;
} else {
rightNode = nextRight;
}
}
}
/** Stores references to two nodes viewed as one minimum and one maximum. The static factory method populates properly the instance being build */
private static class Comparision {
private final Node min;
private final Node max;
private Comparision(Node min, Node max) {
this.min = min;
this.max = max;
}
private static Comparision perform(Node a, Node b) {
Node min, max;
if (a != null && b != null) {
int comparision = a.compareTo(b);
if (comparision <= 0) {
min = a;
max = b;
} else {
min = b;
max = a;
}
} else {
max = null;
min = (a != null) ? a : b;
}
return new Comparision(min, max);
}
}
// Test example....
public static void main(String args[]) {
Node firstLeft = buildList(20);
Node firstRight = buildList(40);
Node firstBoth = merge(firstLeft, firstRight);
System.out.println(firstBoth);
}
// someone need to write something like this i guess...
public static Node buildList(int size) {
Random r = new Random();
Node<Integer> first = new Node<>();
first.data = 0;
first.next = null;
Node<Integer> current = first;
Integer last = first.data;
for (int i = 1; i < size; i++) {
Node<Integer> node = new Node<>();
node.data = last + r.nextInt(5);
last = node.data;
node.next = null;
current.next = node;
current = node;
}
return first;
}
}