আমি সমাধানটি কীভাবে ভাবলাম তা ভাগ করে নিতে চাই ... আমি সমাধানটি পুনর্বিবেচনার সাথে জড়িত দেখে দেখেছি এবং সেগুলি বেশ আশ্চর্যজনক, এটি কার্যকরী এবং মডুলার চিন্তার ফলাফল। আমি সত্যিই ভাগ করে নেওয়ার প্রশংসা করি।
আমি যুক্ত করতে চাই যে পুনরাবৃত্তি বড় চোটের জন্য কাজ করবে না, স্ট্যাক কলগুলি উপচে পড়বে; তাই আমি পুনরাবৃত্তি পদ্ধতির চেষ্টা করার সিদ্ধান্ত নিয়েছি ... এবং এটি আমি পেয়েছি।
কোডটি বেশ স্ব-বর্ণনামূলক, আমি এটির আশ্বাস দেওয়ার জন্য কিছু ইনলাইন মন্তব্য যুক্ত করেছি।
যদি আপনি এটি না পান তবে দয়া করে আমাকে জানান এবং আমি পাঠযোগ্যতার উন্নতি করব (সম্ভবত আমার নিজের কোডের একটি বিভ্রান্তিমূলক ব্যাখ্যা করছি)।
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;
}
}