while(number){
     if(number & 1)
            NumOnes++;
           number = number >> 1;
 }

 return number
}

int StrToInt(char str[])

{

    int i = 0, IsNeg = 0, num = 0;

    if(str[0] == '-'){

        IsNeg = 1;

        i = 1;

    }

    while(str[i]){

        num *= 10;

        num += (str[i++] - '0');

    }

    if(IsNeg)

        num *= -1;

    return num;

}

根据二元搜索树的特性，这里有个隐含的条件：

    除了最低公共祖先之外，其他所有节点要不都是大于该两个节点，要不就是都是小于该两个节点值

算法：

检查当前节点

如果value1&value2同时小于当前节点的值

    前进到当前节点的左节点

如果value1&value2同时大于当前节点的值

    前进到当前节点的有节点

否则

    当前节点就是我们要找到的最低公共祖先

int FindLowestCommonAncestor(node *root, int value1, int value2)

{

    node *CurNode = root;

    while(1){

        /*Go to the left child*/

        if(CurNode->value > value1 && CurNode->value > value2)

            CurNode = CurNode->left;

        /*Go to the right child*/

        else if(CurNode->valuef < value1 && CurNode->value < value2)

            CurNode = CurNode->right;

        /*Else you found the correct node */

        else

            return CurNode->value;

    }

}

void PreOderTranversal(node *root)

{

    element *TheStack;

    void *data;

    node *CurNode;

    CreateStack(&TheStack);

    Push(&TheStack, root);

    while(Pop(&TheStack, &data)){

        CurNode = (node *)data;

        if(CurNode){

            printf("%d\n", CurNode->value);

            Push(&TheStack, CurNode->right);

            Push(&TheStack, CurNode->left);

        }

    }

    DeleteStack(&TheStack);

}

element *FindMToLast(element *head, int m){

    int i;

    element *CurPos, *MToCurPos;

    CurPos = head;

    for(i=0; i<m; i++){

        if(CurPos->next){

            CurPos = CurPos->next;

        }else{

            /* 不到M个元素*/

            return NULL;

        }

    }

    /*Start mbehind at beginning and advanced pointers

    *together until current hits last element

    */

    MToCurPos = head;

    while(current->next){

        current = current->next;

        MToCurPos = MToCurPos->next;

    }

    /*

    *MToCurPos now points to the element we were

    *searching for, so return it

    */

    return MToCurPos;

}

写出在链表中删除/插入一个元素的算法.

typedef struct elemT{

    void *data;

    struct elemT *next;

}element;

#define OK 1

#define ERROR 0

element *head;

element *tail;

删除:应该考虑的问题有:

1 、当删除的是head时应该如何处理

2 、当删除的是tail时应该如何处理

3 、当删除的是list中间的成员时应该如何处理

4 、当list只有一个成员时应该如何处理

int DeleteElem(element *elem){

    element *CurPos;

    CurPos = head;

    if(!elem)

        return 0;

    if(elem == head){

        head = head->next;

        free(elem);

        /*special case for 1 element list*/

        if(!head)

            tail = NULL;

        return OK;

    }

    while(CurPos){

        if(CurPos->next = elem){

            CurPos->next = elem->next;

            free(elem);

            if(CurPos->next == NULL)

                tail = CurPos;

            return 1;  

        }

        CurPos = CurPos->next;

    }

    return 0;

}

插入：应该考虑的情况有：

1 、插入在表头，即elem == NULL;

2 、当表是空表时，即head=tail==NULL;

int InsertAfter(element *elem, int data){

    element *NewAdd;

    element *CurPos;

    CurPos = head;

    NewAdd = (element *)malloc(sizeof(element));

    if(!NewAdd)

        return ERROR;

    NewAdd->data = data;

    /*Special for insert in the head*/

    if(!elem){

        NewAdd->next = head;

        head = NewAdd;

        /*Special for a NULL List,Need to modify tail pointer*/

        if(!tail)

            tail = NewAdd;

        return 1;

    }

    while(CurPos){

        if(CurPos == elem){

            NewAdd->next = elem->next;

            elem->next = NewAdd;

            /*Special for insert in the tail*/

            if(!(NewAdd->next))

                tail = NewAdd;

            return 1;

        }

        CurPos = CurPos->next;

    }

    /*Insert Position not found */

    free(NewAdd);

    return 0;

}