笔试算法题（07）：还原后序遍历数组 & 半翻转英文句段

出题：输入一个整数数组，判断该数组是否符合一个二元查找树的后序遍历（给定整数数组，判定其是否满足某二元查找树的后序遍历）；

分析：利用后序遍历对应到二元查找树的性质（序列最后一个元素必定是根节点，从左向右第一个比根节点大的元素开始直到根节点之前的所有元素必定在右子树，之前的所有元素必定在左子树）；

解题：

bool PostOrderCheck(int *array, int i, int j) {
        /**
         * 如快速排序一样，解决小子文件
         * */
        if(j-i+1 == 3) {
                if(array[i]<=array[i+2] && array[i+2]<=array[i+1])
                        return true;
                else
                        return false;
        } else if(i-i+1 == 2) {
                if(array[i]<=array[i+1] || array[i]>=array[i+1])
                        return true;
                else
                        return false;
        }

        int left=i, right=j-1;
        /**
         * 一共有四种情况：指针交叉后跳出，指针未交叉即跳出，left到达最右边，right到达最左边
         * 如果第二种情况成立则判定必定失败
         * */
        while(left<j) {
                if(array[left]>array[j])
                        break;
                left++;
        }
        while(right>=i) {
                if(array[right]<array[j])
                        break;
                right--;
        }
        /**
         * 两种特殊情况：只有左子树或者只有右子树的递归
         * */
        if(left==j || right<i)
                return PostOrderCheck(array, i, j-1);
        /**
         * 另外两种跳出情况，break，此时left和right不可能重合
         * */
        if(left>right) {
                /**
                 * 如果left比right大，说明成功交叉
                 * */
                return PostOrderCheck(array, i, right) || PostOrderCheck(array, left, j-1);
        } else {
                /**
                 * 如果left比right小，说明左子树中有元素比根节点大，或者右子树中有元素比根节点小
                 * */
                return false;
        }
}

出题：输入一个英文句子，其中的单词以空格符号隔开；要求翻转句子中单词的顺序，但是单词内字符顺序不变（简单起见，标点符号和普通字母一样处理）；

分析：两次翻转，全局翻转（针对所有字符）和局部翻转（针对两个空格符之间的字符）

解题：

/**
 * 借用之前已经实现的全局翻转函数reverse
 * */
void reverse(char* target, int length) {
        char temp;
        int i;
        for(i=0;i<length/2;i++) {
                temp=*(target+i);
                *(target+i)=*(target+(length-i-1));
                *(target+(length-i-1))=temp;
        }
}
void DoubleTransfer(char *target, int length) {
        /**
         * 首先进行全局翻转，得到!tneduts a ma i
         * */
        reverse(target, length);
        char *part=NULL;
        int partLength;
        /**
         * 然后进行局部翻转，从第一个非空格符的字符开始计算
         * 子子序列的长度，直到第一个空格符号结束，然后
         * 调用reverse进行局部翻转，最后进入下一个iteration
         * */
        for(int i=0;i<length;i++) {
                partLength=0;
                while(target[i] == ' ' && i<length) i++;
                part=target+i;
                while(target[i] != ' ' && i<length) {
                        i++;
                        partLength++;
                }
                reverse(part, partLength);
        }
}