笔试算法题（05）：转换BST为双向链表 & 查找栈中的最小元素

出题：把二元查找树转变成排序的双向链表。输入一棵二元查找树，要求将该二元查找树按照中序转换成一个排序的双向链表，要求不能创建任何新的节点，只能调整指针的指向；

分析：

• 递归的思路，当前节点需要进行的处理，并使用递归调用和返回值将子问题链接起来；
• 首先明白二元查找树的特性，变成有序双向链表后当前根节点的左节点为其原来左子树的最右节点，右节点为其原来右子树的最左节点；因此策略就是针对当前根节点索引的子树，首先判断其为上层节点的右子树还是左子树，从而决定返回最右还是最右节点；然后再递归处理当前根节点的左右子树；

解题：

#include <stdio.h>
#include <malloc.h>
#include <string.h>

typedef struct Node {
        int value;
        Node *left;
        Node *right;
} *NodePtr;

Node* MostLeft(Node *current) {
        Node* temp=current;
        while(temp->left!=NULL) {
                temp=temp->left;
        }
        return temp;
}

Node* MostRight(Node *current) {
        Node* temp=current;
        while(temp->right!=NULL) {
                temp=temp->right;
        }
        return temp;
}

Node* Transfer(Node *current, bool isRight) {

        if(current==NULL) return NULL;
        /**
         * 在树结构被破坏之前预先查找好需要返回的节点
         * */
        Node* turnback = (isRight ? MostLeft(current) : MostRight(current));
        /**
         * 递归处理左右子树，将具体返回的节点推迟到子树解决
         * */
        if(current->left!=NULL) {
                current->left=Transfer(current->left,false);
                current->left->right=current;
        }
        if(current->right!=NULL) {
                current->right=Transfer(current->right,true);
                current->right->left=current;
        }
        /**
         * 根据isRight的值，和current是否有左右子树返回不同的节点
         * */
        return turnback;
}

出题：定义stack数据结构，除Push和Pop函数外要求增加Min函数，其功能是找到stack中最小的元素，要求所有函数时间复杂度都是O(1)；

分析：

• 使用辅助stack结构依次将目前的最小元素压入栈，设置CurMin元素记录当前stack中的最小元素，每次Push的新元素都与CurMin比较，若新元素更小则将其压入辅助栈；每次Pop元素都与CurMin比较，若就是CurMin元素则将辅助栈栈顶元素出栈；

解题：

class MyStack {
private:
        int *array;
        int capability;
        int length;
        int head;
        int tail;
public:
        MyStack(int n=10): array((int*)malloc(sizeof(int)*n)), head(0),tail(0),capability(n), length(0) {}
        ~MyStack() {delete [] array;}

        bool isFull() {
                if(length == capability) return true;
                return false;
        }
        bool isEmpty() {
                if(length == 0) return true;
                return false;
        }
/**
 * head当前的指向位置是下一次将push的元素的
 * */
        bool push(int n) {
                if(isFull()) return false;
                array[head]=n;
                head=(head+1)%(capability+1);
                length++;
                return true;
        }
/**
 * tail当前指向的位置是下一次将pop的元素的
 * */
        bool pop(int *n) {
                if(isEmpty()) return false;
                *n=array[tail];
                tail=(tail+1)%(capability+1);
                length--;
                return true;
        }

        void showStack() {
                int i=tail;
                int temp=length;
                printf("
new path
");
                while(temp>0) {
                        printf("%d, ",array[i++]);
                        temp--;
                }
        }
};


class MinStack {
private:
        MyStack *mainStack;
        MyStack *assiStack;
        int curMin;
public:
        MinStack(): mainStack(new MyStack()),assiStack(new MyStack()),curMin(0) {}
        /**
         * 仅当出现新的最小元素时，才将前一个最小元素压入assiStack
         * */
        bool push(int n) {
                if(mainStack->push(n)) {
                        if(n<curMin) {
                                assiStack->push(curMin);
                                curMin=n;
                        }
                        return true;
                }
                return false;
        }
        /**
         * 仅当mianStack的pop元素等于curMin时，才从assiStack中新pop出一个元素
         * */
        bool pop(int *n) {
                if(mainStack->pop(n)) {
                        if(*n == curMin) {
                                int *temp;
                                assiStack->pop(temp);
                                curMin=*temp;
                        }
                        return true;
                }
                return false;
        }
        int min() {
                return curMin;
        }
};