How to merge two descending singly linkedlist into one ascending linkedlist using Recursion without any helper method?
Compilation Error
The first problem is to solve the compiling error.
Just follow the interface:
    public Node&lt;Integer&gt; mergeAscend(Node&lt;Integer&gt; a, Node&lt;Integer&gt; b) 

Warnings and Code convention
You should add the type information to the store_next_a_node variable (and store_next_b_node). Additionally, in Java naming conversion, variable names use camel case. Therefore, I suggest substitute:
            Node store_next_a_node = a.next;
           ...
            Node store_next_b_node = b.next;


By...
            Node&lt;Integer&gt; nextNode = a.next;

Simple &quot;Test Case&quot;
The code bellow is just an example and not a full automated test (for more information, look for Java automated tests. eg: junit tutorial).But it is enough to  give us some hints what is going on. For example, we can see the original code does not solve the problem. Let us write a simple test case:
    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] a = { 6, 4, 2 };
        Node&lt;Integer&gt; h1 = new Node&lt;&gt;(8, null);
        Node&lt;Integer&gt; previous = h1;
        for (int value : a) {
            Node&lt;Integer&gt; node = new Node&lt;&gt;(value, null);
            previous.next = node;
            previous = node;
        }


        int[] b = { 7, 5, 3, 1 };
        Node&lt;Integer&gt; h2 = new Node&lt;&gt;(9, null);
        previous = h2;
        for (int value : b) {
            Node&lt;Integer&gt; node = new Node&lt;&gt;(value, null);
            previous.next = node;
            previous = node;
        }
        solution.mergeAscend(h1, h2);
        Node&lt;Integer&gt; iterator = solution.dummy;
        while (iterator != null) {
            System.out.println(iterator.value);
            iterator = iterator.next;
        }
    }


The expected output would be the numbers printed in ascending order as the exercise suggests.
NullPointerException
With the test case, we can execute the code and and we will get a null pointer exception during the execution:
Exception in thread &quot;main&quot; java.lang.NullPointerException
    at Solution.mergeAscend(Solution.java:13)
    at Solution.mergeAscend(Solution.java:19)
    at Solution.mergeAscend(Solution.java:24)
    at Solution.mergeAscend(Solution.java:19)
    at Solution.mergeAscend(Solution.java:24)
    at Solution.mergeAscend(Solution.java:19)
    at Solution.mergeAscend(Solution.java:24)
    at Solution.mergeAscend(Solution.java:19)
    at Solution.mergeAscend(Solution.java:24)
    at Solution.main(Solution.java:50)

Bug
If you look the code, the following statement is suspicious:
if((a!=null&amp;&amp;b==null)||a.value&gt;=b.value)

What if a is null and b is not null? First condition is false and Java interpreter will try to evaluate the second condition. Unfortunately, a.value will throw a NullPointerException.
Next Step: How to fix it ?
Clean Code makes our life easier
Let's make the code cleaner . In our case, we want to preserve the original code ideas and just simplifying what is possible. Hopefully we will remove the conditions that make the code to fail.
Remove unnecessary else-statement
First, after the base case, we don't need a else-statement. Change..
        if (a == null &amp;&amp; b == null) {//base case
            return null;
        }
        else {
        ...
        }


to
        if (a == null &amp;&amp; b == null) {//base case
            return null;
        }
        ...


Nullability test only once
Second, remove the complication of testing a nullability all the time.
Just add the following check after the base case.
        if (a == null)
            return mergeAscend(b, a);

With that, now we know that a is the longest list and we don't need to check again and again that condition.
So, your second &quot;if-statement&quot; can be change from
        if ( (a!=null &amp;&amp; b==null) || a.value &gt;= b.value)

to:
        if (b == null || a.value &gt;= b.value) // insert &quot;b&quot; after dummy

Remove unnecessary if-statement
After that, we might think about it... we don't need the third &quot;if-statement&quot;. Just remove it.
 else if((a==null&amp;&amp;b!=null)||a.value&lt;b.value){
     ...
 }

To...
 else {
      ...
  }

Congrats, your code now works!
    public Node&lt;Integer&gt; mergeAscend(Node&lt;Integer&gt; a, Node&lt;Integer&gt; b) {
        if (a == null &amp;&amp; b == null) {//base case
            return null;
        }
        if (a == null)
            return mergeAscend(b, a);
        if (b == null || a.value &gt;= b.value) {// insert &quot;a&quot; after dummy
            //store the next node of current a, before pointing a.next to dummy.next;
            Node&lt;Integer&gt; nextNode = a.next;
            //insert Node &quot;a&quot; between dummy and dummy.next
            a.next = dummy.next;
            dummy.next = a;
            mergeAscend(nextNode, b);
        } else {
            Node&lt;Integer&gt; nextNode = b.next;
            b.next = dummy.next;
            dummy.next = b;
            mergeAscend(a, nextNode);
        }
        return dummy.next;
    }

Test it!
PS: Another Minor Thing - Comment misleading
Your code comments are misleading. In the second if-statement, if the statement evaluate the expression as true, code below add a between dummy and dummy.next.
change
// insert &quot;b&quot; after dummy

To
// insert &quot;a&quot; after dummy

PS2: Symmetric symplification
Evaluating the code again, we might found the code is a little redundant. It means, part of the code is doing exactly the same thing, but the variable names are just swapped. In that case, we can simplify it further.
    public Node&lt;Integer&gt; mergeAscend(Node&lt;Integer&gt; a, Node&lt;Integer&gt; b) {
        if (a == null &amp;&amp; b == null) {//base case
            return dummy.next;
        }
        if (a == null || (b != null &amp;&amp; a.value &lt; b.value)) { // symmetric case
            return mergeAscend(b, a);
        }
        //store the next node of current a, before pointing a.next to dummy.next;
        //insert Node &quot;a&quot; between dummy and dummy.next
        Node&lt;Integer&gt; nextNode = a.next;
        a.next = dummy.next;
        dummy.next = a;
        return mergeAscend(nextNode, b);
    }