笔试题

#include<stack>
#include<vector>
#include<string>
using namespace std;

/*
*利用两个栈实现一个队列
*/
template<class T> class Queue{
public:
    Queue(){
    }
    ~Queue(){
    }
    void push(const T& t);
    T pop();
private:
    stack<T> s1; 
    stack<T> s2;
};
template <class T> void Queue<T>::push(const T& t){
    s1.push(t);
}
template <class T> T Queue<T>::pop(){
    if (s2.size()==0){
        while (s1.size()>0){
            T t = s1.top();
            s2.push(t);
            s1.pop();
        }
    }
    T t = s2.top();
    s2.pop();
    return t;
}
/*
*Newton's method:牛顿迭代法是一种在实数和复数域上近似求解方程f(x)=0的方法
*是把非线性方方程f(x)=0线性化的一种近似方法；把f(x)在点x0的某领域内展开成
*泰勒级数，取其线性部分（即泰勒级数的前两项）f(x0)+f'(x0)(x-x0)=0；并以此
*作为非线性方程f(x)=0的近似方程,若f'(x0)！=0,则其解为x1=x0-f(x0)/f'(x0)
*/
//以x^2=N为例，求解x
double sq(double N){
    double x0 = 1.3;
    double x1 = x0 - (x0*x0-N) / (2.0 * x0);
    while (fabs(x1 - x0) > 0.001){
        x0 = x1;
        x1 = x0 - (x0*x0 - N) / (2.0 * x0);
    }
    return x0;
}
/*
*primeFactors:质因数
*函数功能：分解质因数是把一个数分解成几个质数相乘的形式表示
*短除法：用能整除这个合数的最小质数去除，商若是合数继续照上
*        述方法除，直到商为质数
*/
void primeFactors(int n,int ret[]){
    int j=0;
    for (int i = 2; i <= n;i++){
        while (n != i){
            if (n%i != 0)
                break; //不能整除肯定不是因数，能够整除一定是质数；
                       //因为被所有的2，3，5，7整除之后，因数只能是奇数且是质数
            ret[j++] = i;
            n /= i;
        }
    }
    ret[j] = n;
}

/*
*gcd:greatest common divisor
*函数功能：利用辗转相除法(欧几里得算法)，求x,y的最大公约数
*输入：x和y
*返回值:最大公约数x
*/
int gcd(int x,int y){
    int r;
    while (y != 0){ //无需比较x,y大小
        r = x%y;
        x = y;
        y = r;
    }
    return x;
}
//最小公倍数（lowest common multiple）：lcm(x,y)*gcd(x,y)=x*y
int lcm(int x, int y){
    return x*y / gcd(x,y);
}

//将一个数插入，已经排好的序列中
int* insert(int* a, int N, int num){
    int temp1, temp2;
    for (int i = 0; i<N; i++){
        if (a[i]>num){
            temp1 = a[i];
            a[i] = num;
            for (int j = i + 1; j<N + 1; j++){
                temp2 = a[j];
                a[j] = temp1;
                temp1 = temp2;
            }
            break;
        }
    }
    return a;
}

/*
*getGary
*基于格雷码是反射码的事实，利用递归的如下规则来构造：
*1. (n+1)位格雷码中的前2^n个码字等于n位格雷码的码字，按顺序书写，加前缀0
*2. (n+1)位格雷码中的后2^n个码字等于n位格雷码的码字，按逆序书写，加前缀1
*3. n+1位格雷码的集合 = n位格雷码集合(顺序)加前缀0 + n位格雷码集合(逆序)加前缀1
*/
vector<string> getGray(int n){
    if (n == 1){
        vector<string> gray;
        gray.push_back("0");
        gray.push_back("1");
        return gray;
    }
    vector<string> lastGray;
    lastGray = getGray(n - 1);
    int length = lastGray.size();
    vector<string> gray(2 * length);
    for (int i = 0; i<length; i++){
        gray[i] = "0" + lastGray.at(i); //前2^n个码字等于n位格雷码的码字，按顺序书写
        gray[2 * length - i - 1] = "1" + lastGray.at(i); //后2^n个码字等于n位格雷码的码字，按逆序书写
    }
    return gray;
}

/*
*multiLargeNum
*两个大数相由于数字无法用一个整型变量存储，
*则用字符串来表示一串数字。按照乘法运算规则，
*用一个乘数的每一个位乘以另一个乘数，然后将所有中间
*结果按正确位置相加得到最终结果。可以分析出乘数A和B;
*A的位数为m，B的位数为n,则乘积结果为m+n-1(最高位无进位)
*或m+n位（最高位有进位）。
*/

/*
*reverseOrder
*为了符合我们的乘法逻辑运算；可以将数字逆序存储；
*这样数字的低位就在数组的低下标位置
*函数功能：将p和q之间的字符逆序
*/
void reverseOrder(char* str, int p, int q){
    char temp;
    while (p<q){
        temp = str[q]; 
        str[q] = str[p];
        str[p] = temp;
        p++;
        q--;
    }
}
char* multiLargeNum(char*A, char*B){
    //计算A*B
    int m = strlen(A);
    int n = strlen(B);
    char* result = (char*)malloc((m + n + 1)*sizeof(char));
    memset(result, '0', m + n);
    result[m + n] = '\0';
    reverseOrder(A, 0, m - 1);
    reverseOrder(B, 0, n - 1);
    int multiFlag;  //乘积进位
    int addFlag;   //加法进位
    for (int i = 0; i<n; i++){  //B的每一位
        multiFlag = 0;
        addFlag = 0;
        for (int j = 0; j<m; j++){  //A的每一位
            int temp1 = (B[i] - 48)*(A[j] - 48) + multiFlag;    //0的ASCII为48
            multiFlag = temp1 / 10;
            temp1 = temp1 % 10;
            int temp2 = (result[i + j] - 48) + temp1 + addFlag;
            addFlag = temp2 / 10;
            result[i + j] = temp2 % 10 + 48;
        }
        result[i + m] += addFlag + multiFlag; //B[i]*A的每一位后最高位的进位
    }
    reverseOrder(result, 0, m + n - 1);
    return result;
}
/*
*copy
*函数功能：这样写安全漏洞比较多；必须为目标子串分配足够的空间
*/
char* strCopy(char* strDest, char* strSrc){
    char* ret = strDest;
    while ((*strDest++ = *strSrc++));
    return ret;
}

//palindrome:递归的实现回文
int isPalindrome(char* str,int n){
    if (n <= 1)
        return 1;
    else if (str[0] == str[n - 1])
        return isPalindrome(str + 1, n - 2);
    else
        return 0;
}
//palindrom number回文数
int isPalindromeNum(int n){
    int num = n;
    int temp = 0;
    while (num){
        temp = temp * 10 + num % 10;
        num = num / 10;
    }
    return n == temp;
}
/*
*stringFilter:字符串中去掉重复的字符
*/
char* stringFilter(char* str,char* ret){
    int flag[26] = { 0 };
    char* p = str;
    int i = 0;
    while (*p){
        if (flag[*p - 'a'])
            p++;
        else{
            ret[i++] = *p;
            flag[*p - 'a'] = 1;
            p++;
        }
    }
    ret[i] = '\0';
    return ret;
}
/* 
C/C++中用scanf()或cin输入时遇到空格而使其后面的字符无法接收
注:[]字符集合；[^]其补集，scanf(“%[^\n]”,str);可以接收空格符；
scanf(“%s”,str);不能接收空格符，遇到空格后残存信息存在stdin中而不是键盘缓存区；
scanf()函数应该只是扫描stdin流；可以用fflush(stdin)清除stdin流。
输入类型与格式化字符串不匹配导致stdin流的阻塞。
gets()：从标准输入设备读字符串函数。可以无限读取，不会判断上限，以回车结束读取。
char* gets(char* str);读到’\n’（回车）停止读取，但是它不会吧\n包含到字符串里面去，然后在末尾添加’\0’。
cin.getline(str,num);或cin.getline(str,num,delimt);可以接收包含空格的字符串；读到’\n’（回车）停止读取，
但是它不会吧\n包含到字符串里面去，然后在末尾添加’\0’。
*/