笔试算法题（10）：深度优先，广度优先以及层序遍历 & 第一个仅出现一次的字符

出题：要求实现层序遍历二元搜索树，并对比BFS与DFS的区别

分析：层序遍历也就是由上至下，从左到右的遍历每一层的节点，类似于BFS的策略，使用Queue可以实现，BFS不能用递归实现（由于每一层都需要存储所有节点，所以非常耗用内存）。这段代码主要用于反映BFS与DFS的联系；

解题：

class Node {
public:
        int value;
        Node *left;
        Node *right;
};

class MyStack {
private:
        Node *array[];
        int capability;
        int top;
public:
        MyStack(int cap=5): array((Node**)malloc(sizeof(Node*)*cap)), capability(cap), top(0) {}
        ~MyStack() {
                for(int i=0;i<top;i++)
                        delete array[i];
                delete [] array;
        }

        bool isFull() {
                return top == capability;
        }
        bool isEmpty() {
                return top == 0;
        }
        int freeSlot() {
                return capability - top;
        }

        /**
         * top当前的位置就是下一个push元素所在的slot
         * */
        bool push(Node *n) {
                if(isFull()) return false;
                array[top++]=n;
                return true;
        }
        Node* pop() {
                if(isEmpty()) return false;
                return array[--top];
        }
        void ShowStack() {
                int temp=top-1;
                printf("
");
                for(int i=0;i<=temp;i++)
                        printf("%d, ",array[i]->value);
                printf("
");
        }

};

class MyQueue {
private:
        Node *array[];
        int capability;
        int length;
        int head;
        int tail;
public:
        MyQueue(int n=5): array((Node**)malloc(sizeof(Node*)*n)), head(0),tail(0),capability(n), length(0) {}
        ~MyQueue() {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(Node *n) {
                if(isFull()) return false;
                array[head]=n;

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

        void showQueue() {
                int i=tail;
                int temp=length;
                printf("
current stack elements: 
");
                while(temp>0) {
                        printf("%d, ",array[i++]->value);
                        temp--;
                }
        }
};
/**
 * 只要把MyQueue *queue=new MyQueue()换成
 * MyStack *stack=new MyStack()
 * 其他代码不变，就是dfs
 * */
void bfs(Node *root) {
        MyQueue *queue=new MyQueue();
        Node *current;
        printf("%d, ", root->value);
        while(!queue->isEmpty()) {
                current=queue->pop();
                if(current->left != NULL) {
                        printf("%d, ", current->left->value);
                        queue->push(current->left);
                }
                if(current->right != NULL) {
                        printf("%d, ", current->right->value);
                        queue->push(current->right);
                }
        }
        delete queue;
}

出题：在一个字符串中找到第一个仅出现过一次的字符；

分析：

• 解法1：创建辅助链表顺序存储仅出现过一次字符；每当从字符串中扫描一个新字符都遍历辅助链表，如果有相同值则删除对应的链表节点，如果没有相同值则存储 在链表尾，直到扫描完所有字符；最终辅助链表头节点就是第一次仅出现过一次的字符；时间复杂度分析：最坏情况当所有字符都仅出现一次，O（n2），最好情 况O（n）；
• 解法2：一般涉及到大范围分布的有限字符，并且需要记录字符出现次数或者其他累加值的时候，哈希表（Hash Table）往往是第一选择；表宽度是所有可能出现的字符个数，256个，这样位置信息也就是字符编码；每一个slot记录的信息是对应位置的字符是否出 现超过1次，如果有严格的空间要求可以使用2bit的BitMap，简单起见可以直接使用int类型。当第一遍扫描字符串之后，字符信息就已经映射到 Hash Table中，第二遍再次扫描字符串，并在Hash Table中查找对应的出现次数，一旦遇到仅出现一次的字符，扫描结束，如果没有则扫描失败。如果不计Hash Function的时间，时间复杂度为O（n），Hash Function正好是解法1中顺序遍历放的优化，对于复杂的Hash Function，其时间复杂度有关键性影响；

解题：

char FindFirstChar(const char *target) {
        const char *current=target;
        int hashTable[256];

        /**
         * 需要将Hash Table初始化，可以使用memset所有内存储都设置为0；
         * 对于256大小的Table，其不能处理宽字符的情况
         * */
        //memset(hashTable, 0, sizeof(int)*256);
        for(int i=0;i<256;i++) {
                hashTable[i]=0;
        }

        /**
         * 这里可能出现的问题是当字符重复次数过多，int可能溢出，所以优化版本
         * 使用2代表所有出现超过一次的情况
         * */
        while(*current != '') {
                if(hashTable[*current] == 2) {
                        current++;
                } else {
                        hashTable[*current]++;
                        current++;
                }
        }

        current=target;
        while(*current != '') {
                if(hashTable[*current] == 1) {
                        return *current;
                }
                current++;
        }
        /**
         * 当从这里返回则说明所有字符都出现超过一次，所以返回-1，表示
         * 没有任何可行字符，所以调用函数需要使用int类型，然后判断是否
         * 为-1，如果不是才转换为char类型
         * */
        return -1;
}

int main() {
        const char *target="1234561234567";
        int temp=(int)FindFirstChar(target);
        if(temp!=-1) {
                printf("
the first char is : %c
",(char)temp);
        } else
                printf("
all chars are repeated more than once
");

        return 0;
}