笔试算法题（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=): array((Node**)malloc(sizeof(Node*)*cap)), capability(cap), top() {}
         ~MyStack() {
                 for(int i=;i<top;i++)
                         delete array[i];
                 delete [] array;
         }

         bool isFull() {
                 return top == capability;
         }
         bool isEmpty() {
                 return top == ;
         }
         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-;
                 printf("\n");
                 for(int i=;i<=temp;i++)
                         printf("%d, ",array[i]->value);
                 printf("\n");
         }

 };

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

         bool isFull() {
                 if(length == capability) return true;
                 return false;
         }
         bool isEmpty() {
                 if(length == ) return true;
                 return false;
         }
         int freeSlot() {
                 return capability-length;
         }
         void setBack() {
                 length=;
         }
 /**
  * head当前的指向位置是下一次将push的元素的
  * */
         bool push(Node *n) {
                 if(isFull()) return false;
                 array[head]=n;

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

         void showQueue() {
                 int i=tail;
                 int temp=length;
                 printf("\ncurrent stack elements: \n");
                 while(temp>) {
                         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[];

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

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

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

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

         return ;
 }