爱奇艺笔试编程题 （学习之旅）

NO.7

今天参加了爱奇艺的笔试，来分享一下编程题，就是很简单的两道题：
1.在一个字符串中找到第一个出现一次的字符，并返回ascii 码

public class main {
    public static char firstOne(String s)
    {
        int result = 0;
        char temp;
        int[] num = new int[52];
        for (int i = 0; i < s.length(); i ++)
        {
            temp = s.charAt(i);
            //判断字符，
            if ( temp >= 'a' && temp <= 'z' )
            {
                num[temp - 'a']++;
            }
            else
                if (temp >= 'A' && temp <= 'Z')
                {
                    num[temp - 'A' + 26] ++;
                }
        }
        //如果只出现一次。且是第一次，直接输出，然后break;
        for (int i = 0; i < num.length; i ++)
        {
            if (num[i] == 1)
            {
                if (i >= 0 && i <=26)
                {
                    result = i+97;
                }
                else
                    result = i+65-26;
                break;
            }
        }
        return result;
    }
}

大概形式和上面的差不多，只要进行修改一下便可

2.n个人围成一圈，按顺序排序，从第一个人开始报数，报到3 的人退出最后留下的第几号

 public static int main(String[] args) {
        // TODO Auto-generated method stub
        int n = 0 ;
        Scanner input = new Scanner(System.in);
        int p = input.nextInt();
        /**** 初始化人员 ***/
        boolean[] per = new boolean[p];// false表示退出
        for (int i = 0; i < per.length; i++) {
            per[i] = true;
        }

        int t = 0, len = per.length;
        while (len > 1) {
            for (int i = 0; i < per.length; i++) {

                if (per[i]) {
                    t++;
                    if (t == 3) {
                        t = 0;
                        per[i] = false;
                        len--;
                    }
                }          
                  }
        } 
        for (int i = 0; i < per.length; i++) {
            if (per[i]) {
                n = i ;
            }
        }
    return n;
    }

今天做得额外的一道经典算法题：
大概意思就是，把二叉查找树转换成双向链表

//
//  main.c
//  BSTree
//
//  Created by 江志德 on 15/9/26.
//  Copyright © 2015年 江志德. All rights reserved.
//

/*
 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。要求不能创建任何新的结点，只调整指针的指向。 比如将二元查找树
 10
 /        \
 6         14
 /     \      /　 \
 4      8   12 　16
 转换成双向链表

 4=6=8=10=12=14=16。

 分析：本题是微软面试100题的第一题，由于树本身定义就属于递归式定义，所以很多与树相关的题目都是用递归的思路来解决，本题亦是如此。下面我们用两种不同的递归思路来分析。

 思路一：中序遍历的顺序即是我们所要建立链表的顺序。所以可以在中序遍历整棵树的同时，通过调整节点的指针来将其转换为双向链表。当所有结点都访问过之后，整棵树也就转换成一个排序双向链表了。

 思路二：当我们到达某一结点准备调整以该结点为根结点的子树时，先调整其左子树，将左子树转换成一个排好序的左子链表，再调整其右子树转换右子链表。最后链接左子链表的最右结点（左子树的最大结点）、当前结点和右子链表的最左结点（右子树的最小结点）。从树的根结点开始递归调整所有结点。
*/

#include 
#include 
//树的结构
struct BSTreeNode {
    int value;
    struct BSTreeNode *left;
    struct BSTreeNode *right;
};
//
void Convert( struct BSTreeNode * head, struct BSTreeNode * tail, struct BSTreeNode *root ) {
    struct BSTreeNode * left,* right;

    if ( root == NULL ) {
        head = NULL;
        tail  = NULL;
        return;
    }

    Convert( head, tail , root->left );
    Convert(head, tail , root->right );

    if ( left != NULL ) {
        left->right = root;
        root->left = left;
    }
    else {
        head = root;
    }
    if ( right != NULL) {
        root->right = right;
        right->left = root;
    }
    else {
        tail = root;
    }

}

struct BSTreeNode *treeTolinkedList( struct BSTreeNode *root ) {
    struct BSTreeNode *head,*tail;
    Convert( head , tail , root );
    return  head;
}
//创建树，以-1结束
struct BSTreeNode *CreatBSTree() {
    int data;
    struct BSTreeNode *tree;
    scanf("%d " , &data );
    if (data == -1 ) {
        return NULL;
    }
    else {
        tree = ( struct BSTreeNode *)malloc( sizeof(struct BSTreeNode ) ) ;
        tree->value = data;
        tree->right = CreatBSTree();
        tree->left = CreatBSTree();

        return tree;
    }
}

//中序历遍二叉树
void InOrderTraverse( struct BSTreeNode *root ) {
    if (root->left) {
        InOrderTraverse(root->left );
    }
    if (root) {
        printf("%d", root->value ) ;
    }
    if ( root->right ) {
        InOrderTraverse(root->right );
    }
}

int main () {
    struct BSTreeNode *root = CreatBSTree();
    InOrderTraverse(root);

    printf("\n");

    struct BSTreeNode *head = treeTolinkedList( root );

    struct BSTreeNode *temp = head;

    while ( temp != NULL ) {
        printf( "%d", temp->value );
        temp = temp->right;
    }

    getchar();
    return 0;
}