三六零 - milkandbread/summary-interview GitHub Wiki

增加8倍是左移3位。

增加7倍，a=1,b=2,c=4;

d=a|b|c   按位或

d=a^b^c;  异或

string int2str(int num)
{
    string str;
    char s[11]={0123456789};
    int len = 0;
    int tmp = num;

    while(tmp>100)
    {
        tmp /= 100;
        len += 2;
    }
    
    while(tmp>10)
    {
        tmp /= 10;
        len += 1;
    }
    
    while(len>0)
    {
        str = s[num%10]+str;
        len--;
    }
    
    return str;
}

char* int2str(unsigned int values)  
{  
    int len = 0;  
    const char digits[11] = "0123456789";  
    unsigned int tvalue = values;  
    while(tvalue >= 100)  
    {  
        tvalue /= 100;  
        len += 2;  
    }  
    if (tvalue > 10)  
        len += 2;  
    else if(tvalue > 0)  
        len++;  
  
    char* crtn = new char[len+1];  
    crtn += len;  
    *crtn = '\0';  
    do   
    {  
        *--crtn = digits[values%10];  
    } while (values /= 10);  
  
    return crtn;      
} 

vector<int> vt;
//这里多次调用"vt.push_back(111);"插入数据到vt"
vector<int>::iterator it=vt.begin();
vt.push_back(5);
(*it) = 5

会在vt后面添加一个元素5，vt第一个元素被覆盖5.

a）typedef int* typedef_intp;
b) #define define_intp int*
c) typedef_intp ta, tb;
d) define_intp d1, d2;

c 变化后为 int *ta, *tb;  
d 变化后为 int *d1, d2;

char *returnstr()
{
    char s[] = "hello";
    printf("%d\n",sizeof(s));
    printf("%d\n",strlen(s));
    return s;
}
void main()
{
    char *str = returnstr();
    printf("%s\n",str);
}
段错误，因为s为局部变量

int strlen(const char *str)
{
    if(str == NULL)
    {
        return 0;
    }
    int len=0;
    
    while(*str!='\0')
    {
        str++;
        len++;
    }
    return len;
}

struct Node {
    int data;
    Node *next;
}
Node *reverse(Node *header)
{
    struct Node *p1 = header;
    struct Node *p2 = p1->next;
    struct Node *p3 = NULL;
    
    while(p2 != NULL)
    {
        p3 = p2->next;
        p2->next = p1;
        p1= p2;
        p2= p3;
    }
    header = NULL;
    header = p1;
    
    return header;
}

#include <iostream>

using namespace std;

void revesal(char * start, char* end){
    char *temp_s = start;
    char *temp_e = end;
    while(temp_s < temp_e){
        char temp= *temp_s;
        *temp_s= *temp_e;
        *temp_e = temp;
        ++temp_s;
        --temp_e;
    }

    return;
}

void revesal_str(char *str){
    if(str == NULL){
        return;
    }

    char *start = str;
    char *end = str;

    while(*++end !='\0');

    revesal(start, end-1);
    cout << str << endl;
    char *sub_start = str;
    while(start < end + 1 ){
        if(*start == ' ' || *start == '\0'){
            char *temp = start - 1;
            revesal(sub_start,temp);
            while(*++start ==' ');
            sub_start = start;
            continue;
        }
        ++start;
    }
}


int main()
{
	char s[] = "hello world";
	char *p = s;
	revesal_str(p);
	cout<<s<<endl;

	return 0;
}
char *reverse(char *s)
{
    if(s == NULL)
    {
        return NULL;
    }
    char c;
    char *first = s;
    char *end = strlen(s);
    
    while(first != end)
    {
        c = *first;
        first = *end;
        end = c;
        first++;
        end--;
    }
    return s;
}

char *ret_line(char *s)
{
    if(s==NULL)
    {
        return NULL;
    }
    int i=0;
    char *tmp = reverse(s);
    char *first = tmp;
    char *end = tmp;
    
    for(i=0;i<strlen(s);i++)
    {
        if(*end = " ")
        {
            reverse(end-first);
            first=end;
        }
        end++;
    }
    return s;
}

char *R(char *str, int len)             //将句子所有的字母颠倒顺序
	char *pLast = str + len - 1;
	char *pBegin = str;
	char temp;
	while (pBegin < pLast)
	{
		temp = *pBegin;
		*pBegin = *pLast;
		*pLast = temp;
		pBegin++;
		pLast--;
	}
	return str;
}

char *RS(char *str)
{
	char *pBegin = str;
	char *pEnd = str;
	R(str, strlen(str));                       //先将输入的一句话的所有字母全部颠倒顺序
	while (*pEnd != '\0')
	{
		while (*pEnd != '\0' && *pEnd != ' ')
		{
			pEnd++;
		}
		R(pBegin, pEnd - pBegin);           //将每个单词中的字母颠倒顺序，这样就变成了之前的顺序
		if(*pEnd == '\0')
		{
			break;
		}
		pEnd++;
		pBegin = pEnd;
	}
	return str;
}

char ret_first_char(const char *s)
{
    if(s == NULL)
    {
        return "";
    }
    char alph[26]={0};
    while(*s != '\0')
    {
        alph[*s-'a']++;
        s++;
    }
    for(int i=0;i<26;i++)
    {
        if(alph[i] == 1)
        {
            break;
        }
    }
    return i+'a';
}

char firstSingle(char *str)
{
	int arr[256]={0};
	char *pt  = str;
	if (*pt == '\0')
	{
		return '\0';
	}
	memset(arr, 0, sizeof(arr));
	while ('\0' != *pt)
	{
		arr[*pt++]++;
	}
	while ('\0' != *str) 
	{
		if (arr[*str] == 1) 
		{
			return *str;
		}
		str++;
	}
	return '\0';
}

void get_mirror(struct TreeNode *root)
{
    if(root == NULL || (root->left == NULL && root->right == NULL)
    {
        return NULL;
    }
    struct TreeNode *tmp = root->left;
    root->left = root->right;
    root->right = tmp;
    if(root->left != NULL)
    {
        get_mirror(root->left);
    }
    if(root->right != NULL)
    {
        get_mirror(root->right);
    }
}

void get_mirror(struct TreeNode *root)
{
    if(root == NULL || (root->left == NULL && root->right == NULL)
    {
        return NULL;
    }
    struct TreeNode *tmp = NULL;
    stack<TreeNode> stk;
    stk.push(root);
    while(!stk.empty())
    {
        tmp = stk.top();
        stk.pop();
        if(tmp->left != NULL || tmp->right != NULL)
        {
            struct TreeNode *tp = tmp->left;
            tmp->left = tmp->right;
            tmp->right = tp;
        }
        if(tmp->left != NULL)
        {
            stk.push(tmp->left);
        }
        if(tmp->right != NULL)
        {
            stk.push(tmp->right);
        }
    }
}