Explanation :

struct tree* convert(struct tree *root)
{
 struct tree *alist,*blist;
 if(!root)
 return NULL;
 alist=convert(root->left);
 blist=convert(root->right);
 root->left=root->right=root;
 alist=append(alist,root); 
 alist=append(alist,blist);
 return alist;
}

struct tree* append(struct tree *a, struct tree *b)
{
 struct tree *alast,*blast;
 if(a==NULL)
 return b;
 if(b==NULL)
 return a;
 alast=a->left;
 blast=b->left;
 alast->right=b;
 b->left=alast;
 a->left=blast;
 blast->right=a;
 return a;
}

Explanation :

Take arr[HEIGHT] as global               
array and call function printpaths(root,0).
void printpaths(struct tree *root,int pathlen)
 {
  if(root==NULL)
  return;
  arr[pathlen++]=root->data;
  if(root->left == NULL && root->righ t== NULL)
   {
    int i;
    for(i=0 ; i<pathlen;i++)
    printf("%dt", arr[i] );
    printf("n");
   }
  printpaths(root->left,pathlen);
  printpaths(root->right,pathlen);
 }

Explanation :

Method 1:

int isbst(struct tree *root)
 {
  static int min=INT_MIN;
  if(!root)
  return 1;
  if(isbst(root->left) && mindata)
  min=root->data;
  else
  return 0;
  return isbst(root->right);
 }

Method 2:
int isbst(struct tree *root)
 {
  if(!root)
  return 1;
  if(root->data > max(root->left) && root->data < min(root->right))
  return isbst(root->left)&&isbst(root->right)
  return 0;
 }

Explanation :

Method 1:
Store the level order of the binary tree.
This approach is quiet inefficient because if tree is sparse then 
it will take a large number of NULL and this approach will store 
those NULL also. If n is the depth of the tree then in case of 
sparse tree number of NULL's stored is of the order O(2n).
e.g. Say depth of binary tree is 10 but only 10 nodes are in the 
tree, then this storage will store 1000's of NULL in file.

Method 2: 
For sparse trees, we can take 2 values corresponding to each node. 
First to store the array index and second to store the array value.
(think it again)

Method 3: 
Store inorder and preorder or inorder and postorder.
In case of complete binary tree method 1 is best.

Explanation :

Structure of binary tree must contain a parent field.

void inorder(struct tree *root)
 {
  struct tree *p;
  if(!root)
  return;
  while(1)
   {
    while(p->left)
    p=p->left;
    printf("%dn",p->data);
    while(1)
     {
       if(p->right)
        {
         p=p->right;
         break;
        }
       else
        {
         while(p==p->parent->right)
         p=p->parent;
         if(!p)
         return;
         printf("%dn",p->data);
        }
      }
   }
 }