CareerCup

<pre lang="" line="1" title="CodeMonkey95834" class="run-this">struct List
{
int data;
struct List *next;
};
struct List* Reverse(struct List* head)
{
struct List *temp;
if(head==NULL)
return NULL;
if(head->next==NULL)
return head;
temp=reverse(head->next);
head->next->next=head;
return temp;
}</pre><pre title="CodeMonkey95834" input="yes">
</pre>

List reverseList(List head) {
 if(head == null) {
  return null;
 }
 if(head.next == null) {
  return head;
 }
 List tail = head;
 List h = head.next;
 while(tail.next != null) {
  List temp = tail.next;
  tail.next = tail.next.next;
  temp.next = h;
  h = temp;
 }
 return h;
}

public void displayLisReversed(Link currNode)
{
Link pCurrent = currNode; //start at beginning of list

if (pCurrent.pNext != null) //until end of list,
{
displayLisReversed(pCurrent.pNext);
}
pCurrent.displayLink();
}

public class Link
{
public int iData; //data item
public double dData; //data item
public Link pNext; //ptr to next link in list

//-------------------------------------------------------------
public Link(int id, double dd)
{
iData = id;
dData = dd;
pNext = null;
}

//-------------------------------------------------------------
public void displayLink() //display ourself {22, 2.99}
{
Console.WriteLine("iData = " + dData);
}
//-------------------------------------------------------------
}

public Node ReverseList(Node Head)
        {
            Node loop = Head;
            Node reverse = null;
            Node temp = null;

            while (loop != null)
            {
                temp = loop.Next;
                loop.Next = reverse;
                reverse = loop;
                loop = temp;
            }

            return reverse;
        }

void reverse(mynode* head)
{
 mynode*k, *r,*s;
 k=head;r=NULL;
 while(k!=NULL)
 {
  s=r;
  r=k;
  k=k->next;
  r->next=s;
 }
return r;
}
}

public ListNode reverse(ListNode head){
if(head==null)
return null;
if(head.next==null)
return head;
ListNode current=head;
ListNode prev=null;
ListNode temp=null;
while(current!=null){
temp=current.next;
current.next=prev;
prev=current;
current=temp;
}
return prev;
}

Tested and working code, should take care of edge case tests.

Node MakeSingleLinkedListReverse(Node currentNode)
{
    Node previousNode = null;
    Node nextNode = null;
           
    while (currentNode != null)
    {
        nextNode = currentNode.NextNode;
        currentNode.NextNode = previousNode;

        previousNode = currentNode;
        currentNode = nextNode;
    }

    return previousNode;
}