Here is my code to serialize and de-serialize tree github

//  main.cpp
//  tree
//
//  Created by harish divakaran on 2/13/12.
//

#include <iostream>
using namespace std;

struct TreeNode
{
    TreeNode *left;
    TreeNode *right;
    int value;
    TreeNode() { value = 0; left = NULL; right = NULL; }
};
class Tree
{
    private:
        TreeNode *head;
        void __inorder(TreeNode *t);
        void __preorder(TreeNode *t);
        void __postorder(TreeNode *t);
        void __insertNode(TreeNode* &t, int val);
        bool __deleteNode(TreeNode* &node, int value);

    public:
        Tree() { head = NULL;}

        void inOrder() { __inorder(head); }
        void preOrder() { __preorder(head); }
        void postOrder() { __postorder(head); }
        void insertNode(int value) { __insertNode(head, value); }
        bool deleteNode( int value) { return __deleteNode(head, value);}

};

void Tree::__inorder(TreeNode *t)
{
    if(t)
    {
        __inorder(t->left);
        cout<<t->value<<endl;
        __inorder(t->right);
    }
}
void Tree::__preorder(TreeNode *t)
{
    if(t)
    {
        cout<<t->value<<endl;
        __preorder(t->left);
        __preorder(t->right);
    }
}
void Tree::__postorder(TreeNode *t)
{
    if(t)
    {
        __postorder(t->left);
        __postorder(t->right);
        cout<<t->value<<endl;

    }
}
void Tree::__insertNode(TreeNode* &t, int val)
{
    TreeNode *newNode = new TreeNode;
    newNode->value = val;

    if(t == NULL)
    {
        t = newNode;
    }
    else if(val < t->value)
    {
        __insertNode(t->left, val);
    }
    else __insertNode(t->right, val);

}

bool Tree::__deleteNode(TreeNode* &node, int value)
{
    bool retVal = false;
    if(node == NULL)
    {
        retVal = true;
    }
    else if(node->value == value)
    {
        // now we need to delete the root node

        if(node->left == NULL && node->left == NULL)
        {
            TreeNode *tempNode = node;
            node = NULL;
            delete tempNode;
            retVal = true;

        }
        else if(node->left == NULL)
        {
            TreeNode *tempNode = node;
            node = node->right;
            delete tempNode;
            retVal = true;

        }
        else if(node->right == NULL)
        {
            TreeNode *tempNode = node;
            node = node->left;
            delete tempNode;
            retVal = true;
        }
        else
        {
            // now we need to find find the inorder successor

            TreeNode *nextNode = node->right;
            TreeNode *parentNode = node;
            while(nextNode->left == NULL)
            {
                parentNode = nextNode;
                nextNode = nextNode->left;
            }

            // now we need to change data of node 

            node->value = nextNode->value;
            // now delete next Node

            retVal = __deleteNode(nextNode, value);
        }
    }
    else if(node->value > value)
    {
        retVal = __deleteNode(node->left, value);
    }
    else
    {
        retVal = __deleteNode(node->right, value);
    }
    return retVal;
}
int main (int argc, const char * argv[])
{

    // insert code here...

    Tree *t = new Tree();

    int a[10] = {99,1,56,23,45,2,10,12,67,98};
    for(int i = 0; i < 10; i ++)
        t->insertNode(a[i]);

    t->inOrder();
    t->deleteNode(45);
    t->deleteNode(99);

    t->inOrder();

    return 0;
}

int checkPal(char s[])
{
    int i,k;
    int max;
    max  = strlen(s) - 1;

    for(i = 0,k=max;i < k; i++,k--)
        if(s[i] != s[k] ) return 0;

    return 1;
}

int reverseString(char s[], int low, int high)
{
    int i,k;
    i = low;
    k = high;
    for(; i <k ; i++, k--)
    {
        char ch;
        ch = s[i];
        s[i] = s[k];
        s[k] = ch;
    }
}
void reverseWords(char s[])
{
    reverseString(s,0,strlen(s) -1 );
    while(*s)
    {
        int wordlen;
        char *startWord;
        wordlen  = 0;
        while(*s == ' ' && *s) s++; // skip white space
        startWord = s;
        while(*s!= ' ' && *s) s++,wordlen++;
        reverseString(startWord,0,wordlen-1);

    }
}

My brother asked me to reverse words in a sentence. He accused me of cheating by not writing an actual algorithm, but here is the solution I came up in a minute.

' '.join(s.split()[::-1])

harish-macbook:~ h_divakaran$ python
Python 2.7.1 (r271:86832, Jun 16 2011, 16:59:05)
[GCC 4.2.1 (Based on Apple Inc. build 5658) (LLVM build 2335.15.00)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> s = "how are you"
>>> ' '.join(s.split()[::-1])
'you are how'
>>>

C#

    public static string Reverse(string s)
    {
        char [] sbArray = s.ToCharArray();
        int len = s.Length;
        int middle = len/2;

        for (int i = 0; i < middle; i ++)
        {
            char ch = sbArray[i];
            sbArray[i] = sbArray[(len - 1) - i];
            sbArray[(len - 1) -i] = ch;

        }
        return new string(sbArray);
    }

Still C#, but using string builder

    public static string Reverse(string s)
    {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.Length ; i ++)
        {
            sb.Append(s[s.Length - 1 - i]);
        }
        return sb.ToString();
    }

Python

    def Reverse(s):
        return s[::-1]

I have been using Git a lot lately across different machines. Everytime I branch I create a tracking branch. Here is the command I use.

git branch —track version20 origin/version20

This mean local version20 will track remote version20