Singly Linked list implementation in C++ How can I improve this code
Please tell proper indentation and usage of camel-case.

#include &lt;iostream&gt;
using std::cout;
struct Node
{
    int data;
    Node* next;
};
Node* Create(int data){
    Node* root=new Node();
    root-&gt;data=data;
    root-&gt;next=NULL;
    Node* head=root;
    return head;    
}
void push_back(int data,Node* head){
    if(!head-&gt;next)
    {
        Node* newNode=new Node();
        newNode-&gt;data=data;
        newNode-&gt;next=NULL;
        head-&gt;next=newNode;
    }   
    else 
        push_back(data,head-&gt;next);
}
Node* push_front(int data,Node* head){
    Node* newNode=new Node();
    newNode-&gt;data=data;
    newNode-&gt;next=head;
    head=newNode;
    return head;
}
void pull_back(Node* head){
    Node* temp=head;
    if(!temp-&gt;next)
        delete temp;
    else
        pull_back(temp-&gt;next);
}
Node* pull_front(Node* head){
    Node* temp=head-&gt;next;
    delete head;
    Node* NewHead=temp;
    return NewHead;
}
void print(Node* head){
    while(head)
        cout&lt;&lt;head-&gt;data&lt;&lt;" ",
        head=head-&gt;next;
    cout&lt;&lt;"\n";
}
Node* Reverse(Node* head)
{
    Node* prev   = NULL;
    Node* current = head;
    Node* next;
    while (current != NULL)
    {
        next  = current-&gt;next;  
        current-&gt;next = prev;   
        prev = current;
        current = next;
    }
    head = prev;
    return head;
}
int Search(int data,Node* head,int count=1){
    if(head-&gt;data==data)
        return count;
    if(!head-&gt;next)
        return -1;
    return Search(data,head-&gt;next,count+1);
}
Node* MakeCircular(Node* head)
{
    Node* temp=head;
    while(!temp-&gt;next)
        temp=temp-&gt;next;
    temp-&gt;next=head;
    return head;
}
bool DetectCircle(Node* head){
    //using floyd's cycle
    Node* fast=head;
    Node* slow=head;
    if(!(slow &amp;&amp; slow-&gt;next))return false;
    while(fast &amp;&amp; fast-&gt;next){
        slow=slow-&gt;next;
        fast=fast-&gt;next-&gt;next;
        if(slow==fast)
            return true;
    }
    return false;
}
int main(int argc, char const *argv[])
{
    Node* head=Create(12);
    push_back(32,head);
    push_back(123,head);
    head=push_front(-21,head);
    print(head);
    head=Reverse(head);
    print(head);
    return 0;
}
I see a number of things that may help you improve your code.

Prefer references to raw pointers

In modern C++, we tend not to use raw pointers very often.  In this case, It would probably be better to have two different classes, one would be a LinkedList class and the other would be a Node class.  That way, instead of starting with a pointer, you can start with an object.

Use objects

You have a Node structure and then separate functions that operate on Node data. With only a slight syntax change, you would have a real object instead of C-style code written in C++.  

Use whitespace to improve readability

Lines like this:

head=push_front(-21,head);


become much easier to read with a little bit of whitespace:

head = push_front(-21, head);


Use nullptr rather than NULL

Modern C++ uses nullptr rather than NULL.  See this answer for why and how it's useful.  

Use consistent naming

The code includes print() (lowercase) and Search() (uppercase).  It would be better for both functions to have similar case.  I tend to use capital letters to name clases or structs such a Node and then lowercase letters for functions such as print or search.

Match new with delete

If you allocate memory using new, you must also free it using delete or your program will leak memory.  This program leaks memory.  

Use more descriptive names

The code's DetectCircle function seems to return true if the list is circular.  Generally, it's good to name boolean functions so that their sense is unambiguous.  For example, I'd probably call it isCircular.

Omit return 0

If your program completes successfully, the return 0 at the end of main() will be generated automatically, so it's not needed in C++ programs.