笔试算法题（12）：整数的string到int转换 & 两个栈实现队列

出题：将输入的表示整数的字符串转变为对应的整数值；

分析：

• 每当右边增加一位，说明之前的sum应该高一个数量级，所以*10。由于这两个实现仅仅考虑正规的、正整数输入，所以需要一个Wrapper函数，其功能 主要处理：符号判断（第一个字符是-,+或者直接是数字）；非法输入判断（是否有非"0123456789"的字符存在）；
• 另外以string存在的整数极有可能是大整数，所以需要考虑int的溢出的情况，当然这已经超出本议题的范围，不做详细论述；

解题：

int NonRecursiveStrInt(char *target) {
        int sum=0;
        char *index=target;
        while(*index != '') {
                sum*=10;
                sum+=*index-'0';
                index++;
        }
        return sum;
}
int RecursiveStrInt(char *target, int sum) {
        if(*target != '') {
                sum*=10;
                sum+=*target-'0';
                return RecursiveStrInt(target++, sum);
        } else
        {
                return sum;
        }
}
//一个更加robust的版本，可以处理负数，以及包含非数字字符的string的转换
int str2int(char *str) {
        char *temp;bool isnegative=false;
        int sum=0;

        if(*str=='-') {
                isnegative=true;
                temp=str+1;
        } else
                temp=str;

        while(*temp!='') {
                if(*temp<'0' || *temp>'9') {
                        printf("
bad int");
                        return 0;
                }

                sum*=10;
                sum+=*temp-'0';
                temp++;
        }

        if(isnegative)
                sum=-sum;
        return sum;
}


int main() {
        char *target="-324g54s";
        printf("
%d", str2int(target));
        return 0;
}

出题：要求使用两个堆栈结构实现队列

分析：

• 后进先出的模式转变成先进先出，堆栈A负责加入元素，堆栈B负责弹出元素，两种情况下需要将A中的元素弹出并加入B，所有操作均按照堆栈的性质执行：当B 空栈的时候，当A满栈的时候。第一种情况较为简单，检测到B空栈，则将A中元素弹出并加入B；第二种情况需要使用第三个辅助堆栈保存B原有的元素，处理完 A中元素之后再将原有元素压入B栈，并且A中送过来的元素需要满足一定的数量限制，以保证B有足够的空间存储原有的元素；
• 反过来如果要用两个队列实现一个堆栈，能想到的办法是：迭代使用一个队列保存最近压入的元素，迭代发生在弹出元素的时候；

解题：

class MyStack {
private:
        int *array;
        int capability;
        int length;
        int head;
        int tail;
public:
        MyStack(int n=5): 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;
        }
        int freeSlot() {
                return capability-length;
        }
        void setBack() {
                length=0;
        }
/**
 * head当前的指向位置是下一次将push的元素的
 * */
        bool push(int n) {
                if(isFull()) return false;
                array[head]=n;

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

                tail=(tail+1)%(capability);
                length--;
                return true;
        }

        void showStack() {
                int i=tail;
                int temp=length;
                printf("
current stack elements: 
");
                while(temp>0) {
                        printf("%d, ",array[i++]);
                        temp--;
                }
        }
};
/**
 * first用于接收新元素，second用于输出旧元素，
 * assist用于辅助栈
 * */
class MyQueue {
private:
        MyStack *first;
        MyStack *second;
        MyStack *assist;
public:
        MyQueue(int n=5): first(new MyStack(n)), second(new MyStack(n)), assist(new MyStack(n)) {}
        bool push(int e) {
                if(first->isFull()) {
                        /**
                         * freeSlot()可以知道stack中剩余的空位置
                         * */
                        int fs=second->freeSlot();
                        int temp=0;
                        /**
                         * 将second中的元素弹出并加入到assist中
                         *
                         * */
                        while(second->pop(&temp) && assist->push(temp));

                        /**
                         * 从first中的元素弹出并压入second中，注意
                         * 有个数限制
                         * */
                        int i=0;
                        while(i<fs && first->pop(&temp) && second->push(temp)) {
                                i++;
                        }

                        /**
                         * 将second原有的元素从assist中取回，由于之前经过严格
                         * 的个数计算，所以一定可以全数压回
                         * */
                        while(assist->pop(&temp) && second->push(temp));
                        /**
                         * setBack()函数可以将stack重置为0个元素
                         * */
                        assist->setBack();
                }
                if(first->push(e)) return true;
                else return false;
        }
        bool pop(int *e) {
                int temp=0;
                if(second->isEmpty()) {
                        /**
                         * 当second为空的时候，将first中的元素弹出并压入
                         * 到second中，主要当second满栈的时候需要将最后
                         * 一个元素压回first
                         * */
                        while(first->pop(&temp) && second->push(temp));

                        if(second->isFull()) first->push(temp);
                }
                if(second->pop(e)) return true;
                else return false;
        }
};