天道酬勤,学无止境

C++ Knowledge in Coding Interview (面试常用C++知识和技巧)

C++ Knowledge in Coding Interview

  • Some useful C++ knowledge and examples that may be used/asked in a coding interview
  • For more articles like this, please visit https://medium.com/@yangpeng_tech 

Table of Contents

  • Variables definitions, assignments, and initiations
  • Type conversions
  • Pointer
  • Object-Oriented Programming
  • STL
  • Other common usages
  • Explanation of keywords

Variables definitions, assignments and initializations

Uniform initializations

Integers

int a;
int a = 5;
int a(5);
int a{5};

Char

char c;
c = 'a';
c = 97; // same as c = 'a'; cout << c will print 'a' as well.
char c = 'a';
char c('a');
char c{'a'};

Float and double

float f;
f = 5.0f;
float f = 5.0f;
float f(5.0f);
float f{5.0f};
double d;
d = 5.0;
double d = 5.0;
double d(5.0);
double d{5.0};

C-style string

char str[] = "string"; //\0 is added automatically
str = "rope"; // not ok!
char str[] = {'S', 'a', 'm', '\0'}; //\0 is required
char *str = "hi"; //error, 
C++11 does not allow conversion from string literal to 'char *', instead, use below:
const char *str = "hi";

std::string

// init
string str;
str = "string";
string str = "string";
string str("string");
string str{"string"};
string s(4, 'Q'); //QQQQ
string s = 'a';
string s{'a'};
string s("my string");
string str(s);
string str(s, 3); //string
string str(s, 3, 4); //stri
const char *cs("my string");
string str(cs); //my string
string str(cs, 4); //my s (length)

Array

int a[5];
a[0] = 1;
int a[] = { 0, 1, 2, 3 };
int a[] { 0, 1, 2, 3 };
int a[5] = { 0, 1, 2, 3 }; //0,1,2,3,0
int a[5] { 0, 1, 2, 3 }; //0,1,2,3,0

Pointer

int i;
int *p;
p = &i;
p = q; //q is another pointer pointing to int;
int *p = &i;
const int *p = &i; //cannot change value of i via p
int const *p = &i; //same as above
int * const p = &i; // cannot change p
const int * const p = &i;

Dynamic array

  • Using just raw pointers there’s no way to know if they point to an array or a single value. A pointer that is being used as an array and a pointer to a single value are identical — they’re both just a memory address.
char *str;
str = new char[5]{"abcd"};
int *p = new int{5};
int *q = new int[3]{1,2,3};
cout << p << endl; //0x7fa2bec02be0
cout << p+1 << endl; // 0x7fa2bec02be4
cout << q << endl; //0x7fd959c02bf0
cout << q+1 << endl; //0x7fd959c02bf4
delete p;
delete[] q;

Enum

enum Color
{
    COLOR_BLACK,
    COLOR_RED,
    COLOR_BLUE,
    COLOR_GREEN,
    COLOR_WHITE, //the comma here is allowed in C++11
};
Color paint = COLOR_WHITE;
Color house(COLOR_BLUE);
Color apple { COLOR_RED };

Enum Class

enum class Color // "enum class" defines this as a scoped enumeration instead of a standard enumeration
{
    RED, // RED is inside the scope of Color
    BLUE
};
Color color = Color::RED; // note: RED is not directly accessible any more, we have to use Color::RED
Color color(Color::RED);
Color color { Color::RED };

Struct

struct Date
{
    int year;
    int month;
    int day;
};
Date today;
today.year = 2020;
Date today = { 2020, 10, 14 }; //initialization list
Date today { 2020, 10, 14 }; //uniform initialization
struct S1 { int a, b; } s { 0, 1 };

Class

class DateClass
{
public:
    int m_year;
    int m_month;
    int m_day;
    DateClass();//no parameter 
    DateClass(int year, int month, int day);
};
DateClass today(2020,10,14); // constructor DateClass(int, int, int)
DateClass today = { 2020, 10, 14 }; //initialization list, DateClass(int, int, int)
DateClass today { 2020, 10, 14 }; //initialize using parameterized constructor (C++11), DateClass(int, int, int)
// following work only if there is constructor with no parameter
DateClass today;  //DateClass()
today.year = 2020;
//DateClass today(); wrong, empty parentheses interpreted as a //function declaration
DateClass *p = new DateClass(); //DateClass()
DateClass *q = new DateClass; //DateClass()

Type conversions

String

  • convert numbers, char to string
// number to string (basically to_string works for all kinds of numbers)
std::to_string(123); // "123"      (int to string) std::to_string(3.1); // "3.100000" (double to string) std::to_string(.1f); // "0.100000" (float to string)
// another way to convert number and char to string is via stringstream (or simply ostringstream) class
#include <sstream>
std::stringstream ss; 
ss << 3.14; 
string str = ss.str(); // "3.14"
std::stringstream ss; 
ss << 1 << '+' << 2.0 << "=" << 1 + 2; 
string s = ss.str(); // "1+2=3"
// to convert char to string, we can use stringstream as above, or do as below
char ch = 'a'; 
string str{ch}; // "a"
string str(to_string(ch)); //"97" not "a"
string str = to_string(ch) + "test"; //"97test" not "atest"
// Other 
string s;
s += 'a' + 1; //b, 'a' + 1 is of type int, then converted to string
  • convert string to numbers, const char*, char []
// convert string to number using istringsream
std::istringstream iStream("123");
int i; //same works for other numerical types
iStream >> i;
// convert string to number use functions
string str = "3.14";
int i = std::stoi(str); // 3, need to pass str.c_str() in c
double d = std::stod(str); // 3.14, need to pass str.c_str() in c
// convert string to const char *
string s = "hello";
const char *ch = s.c_str();//null terminator appended
// convert string to char[]
string str = "cat";
char ca[4];
strcpy(ca, str.c_str()); //or use strncp
cout << ca << endl; //cat

Pointer

G4G

Basic usage

int var = 10;
int *ptr = &Var;
cout << var << endl; //10 
cout << *ptr << endl; //10
cout << &var << endl; //0x7fffa0757dd4, address of Var
cout << ptr << endl; //0x7fffa0757dd4, value of pointer == address of Var it points to
cout << &ptr << endl; //0x7fff98b499e8, address of pointer
//function pointers
int (*fcnPtr)();
int (*const fcnPtr)(); //cannot change the function points to
int (*fcnPtr)(int); //point to a function with one argument
// pass reference of pointer
void myfunction (int *&p){p == <somevalue>};

3 ways to pass C++ arguments to a function:

  1. call-by-value
  2. call-by-reference with pointer argument (pass by address, address is copied)
  3. call-by-reference with reference argument
//call by value
//Address of n1(&n1) and n(&n) are different
//n1 won't change after function call
int square1(int n){...}
square1(n1);
//Pass-by-Reference with Pointer Arguments
//Address of n2(&n2) and n(n) are the same
//n2 can be changed via the function call
void square2(int *n){...} 
square2(&n2);
//Pass-by-Reference with Reference Arguments
//Address of n3(&n3) and n(&n) are the same
//n3 can be changed via the function call
void square3(int &n){...}
square3(n3);

Passing array to a function

  • C++ does not allow to pass an entire array as an argument to a function. We can pass a pointer to an array by specifying the array’s name without an index. The pointer to the array is copied to the function, thus the value of elements can be changed via the function, but not the the address of the array.
void func(int a[], int n){
 cout << "value of a in func: " << a << endl;
}
void func1(int *a, int n){
 cout << "value of a in func1: " << a<< endl;
}
int a[] = {1,2,3};
cout << "value of a: " << a << endl;
func(a, 3); //func(&a[0], 3) also works
func1(a, 3); //func1(&a[0], 3) also works
value of a: 0x7ffee117e78c
value of a in func: 0x7ffee117e78c
value of a in func1: 0x7ffee117e78c

Array name as pointers and pointer arithmetic

  • An array name contains the address of the first element of the array which acts like a constant pointer. It means, the address stored in the array name can’t be changed.
int a[] = {1,2,3};
int *p = a; //a contains the address of a[0]
a++; //compile error: cannot increment value of type 'int [3]'
p++; //ok, points to a[1]
cout << a+1; //ok, address of a[1]
cout << p+1; //ok, address of a[1]

Pointer and two-dimensional numeric arrays

int nums[2][3]  =  { { 16, 18, 20 }, { 25, 26, 27 } };
  • nums[ i ][ j ] is equivalent to *(*(nums+i)+j), e.g.
*(*nums) == 16
*(*(nums+1)+2) == 27
  • Although nums,*nums and nums[0] have the same value, they have different types. nums is a type of int **, *nums and nums[0] is a type of int * .
value of nums: 0x7ffee1218770
value of *nums: 0x7ffee1218770
value of nums[0]: 0x7ffee1218770
value of nums + 1: 0x7ffee121877c //3 elements * 4 bytes = 12
value of *nums + 1: 0x7ffee1218774 //1 element * 4 bytes = 12
value of nums[0] + 1: 0x7ffee1218774 // 1 elements * 4 = 4
size of nums: 24 // 2 rows * 3 columns * 4 bytes
size of nums[0]: 12 // 3 elements in a row * 4 bytes

Pointers and String literals

  • String literals are arrays containing null-terminated character sequences. String literals are arrays of type character plus terminating null-character, with each of the elements being of type const char (as characters of string can’t be modified).
const char * ptr = "geek";
cout << sizeof("geek") << endl; // 5
ptr[0] = 'a'; //compile error: read-only variable is not assignable
char *ptr1 = "geek";// compile error: conversion from string literal to 'char *' is deprecated

Void pointers

  • Void pointers are pointers that point to a value that has no type (and thus also an undetermined length and undetermined dereferencing properties).
  • Void pointers cannot be directly dereferenced. They have to be first transformed into some other pointer type that points to a concrete data type before being dereferenced.
int a = 0;
void *p = &a;
int *p1 = (int*)p;
cout << *p << endl; //compile error: 
cout << *p1 << endl;//ok, 0

Function pointers

  • In the example below, foo is a pointer to a function taking one argument, an integer, and that returns void.
void my_int_func(int x)
{
    printf( "%d\n", x );
}
void (*foo)(int); // declare a function pointer
foo = &my_int_func; //Initializing Function Pointers, the ampersand is optional
//Use a function pointer
//call my_int_func (note that you do not need to write (*foo)(2))
foo( 2 ); // you can also use (*foo)( 2 );
  • Example uses of function pointers:
  1. Callback Functions
  2. Functions as arguments to other functions (I was asked in one of my video interviews). See the example in another article (Section: Pragmatics of Sorting). The fourth argument of the quicksort function in the standard library (C: stdlib.h, C++: cstdlib) is a function pointer.
void qsort(void *base, size_t num, size_t size, 
           int (*compare)(const void*, const void*))

STL

STL example and explanation, STL has four components:

  • Algorithms: sorting, searching, etc.
  • Containers: vector, stack, set, map, unordered_map, etc
  • Functions: functors
  • Iterators: iterators

 

Algorithms

qsort (standard c library, stdlib.h)

  • Standard C library provides qsort function that can be used for sorting an array.
  • The prototype of qsort() function
// Sort an array of any type. The parameters are, base
// address of array, size of array and pointer to
// comparator function
void qsort(void *base, size_t num, size_t size, 
           int (*compare)(const void*, const void*))
  • Comparator function: it requires two const void* parameters and it returns int.
int comparator(const void* p1, const void* p2);
Return value meaning
<0 The element pointed by p1 goes before the element pointed by p2
0  The element pointed by p1 is equivalent to the element pointed by p2
>0 The element pointed by p1 goes after the element pointed by p2
  • Example of qsort
int compare_int(const void *a, const void *b) // ascending order
{
    return *(int*)a - *(int*)b;
}
int compare_struct(const void *p, const void *q)// ascending order based on marks
{ 
    int l = ((struct Student *)p)->marks; 
    int r = ((struct Student *)q)->marks;  
    return (l - r);
}
int arr[] = {1, 6, 5, 2, 3, 9, 4, 7, 8};
qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), compare_int);
Output: 1,2,3,4,5,6,7,8,9

sort : Japanese explanation

  • C++ STL provides a similar function sort that sorts a vector or array (items with random access).
  • Prototypes of C++ sort() function
// To sort in default or ascending order.
template 
void sort(T first, T last);

// To sort according to the order specified by comp.
template
void sort(T first, T last, Compare comp);
  • The order of equal elements is not guaranteed to be preserved. C++ provides std::stable_sort (same usage as sort) that can be used to preserve order.
  • Comparator cplusplus
  1. Binary function that accepts two elements in the range as arguments, and returns a value convertible to bool.
  2. The value returned indicates whether the element passed as first argument is considered to go before the second in the specific strict weak ordering it defines.
  3. The function shall not modify any of its arguments.
  4. This can either be a function pointer or a function object.
bool myfunction (int i, int j) { return (i<j); }

struct myclass {
  bool operator() (int i,int j) { return (i<j);}
} myobject;
 
int compareSec(const pair<string, int>& a, const pair<string, int>& b) {
    return a.second > b.second;
}
  • Example (ascending order)
//Array
int arr[] = {1, 5, 8, 9, 6, 7, 3, 4, 2, 0};
int n = sizeof(arr)/sizeof(arr[0]);
sort(arr, arr+n);
//Vector
vector<int> data(arr, arr + n);
sort(data.begin(), data.end());
  • Example (descending order)
//Array
int arr[] = {1, 5, 8, 9, 6, 7, 3, 4, 2, 0};
int n = sizeof(arr)/sizeof(arr[0]);
sort(arr, arr+n, greater<int>());
//Vector
vector<int> data(arr, arr + n);
sort(data.begin(), data.end(), greater<int>());
  • Sort elements in unordered_map: It seems impossible to sort elements in unordered_map as sort function only supports containers with random access available (i.e: ele[i]). Thus, to sort elements in unordered_map, we need to make a vector coping data from unordered_map and sort elements of the vector. Example:
//descending order on a basis of second element
int compareSec(const pair<string, int>& a, const pair<string, int>& b) {
    return a.second > b.second;
}
//c++11 unodered_map initialisation
unordered_map<string, int> mp({{"practice", 3}, {"makes", 2}, {"perfect", 1}, {"just", 4}});
vector<pair<string, int>> vec(mp.begin(), mp.end());
sort(vec.begin(), vec.end(), compareSec);
Output of vector:
just 4
practice 3
makes 2
perfect 1
  • Sorting vector of pairs: G4G, G4G. By default, the sort function sorts the vector elements on the basis of the first element of pairs.
  • Sorting vector of vector. By default, it sorts by the first element of each vector in ascending order.
vector<vector<int>>v{{2,1}, {1,3},{4,2}};
sort(v.begin(), v.end());
for(auto i : v){
    cout << i[0] << " " << i[1] << endl;
}
// {1,3}, {2,1}, {4,2}
// sort by second element of the vector in ascending order
int comp(const vector<int> &a, const vector<int> &b){
    return a[1] < b[1];
}

partial_sort

Searching

  • std::binary_search (return bool)
int a[] = { 1, 5, 8, 9, 6, 7, 3, 4, 2, 0 };
int asize = sizeof(a) / sizeof(a[0]);
sort(a, a + asize);
if (std::binary_search(a, a + 10, 2))
    cout << "Element found in the array";
std::vector<int> haystack {1, 3, 4, 5, 9};
if (std::binary_search(haystack.begin(), haystack.end(), needle)) {
    cout << "Found " << needle << '\n';
  • std::bsearch (return void*)
// Binary predicate 
int compare(const void* ap, const void* bp) 
{ 
    // Typecasting 
    const int* a = (int*)ap; 
    const int* b = (int*)bp; 
  
    if (*a < *b) 
        return -1; 
    else if (*a > *b) 
        return 1; 
    else
        return 0; 
}
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; 
int ARR_SIZE = sizeof(arr) / sizeof(arr[0]); 
int key1 = 4;
int* p1 = (int*)std::bsearch(&key1, arr, ARR_SIZE, sizeof(arr[0]), compare);
if (p1) 
    cout << key1 << " found at position " << (p1 - arr);

Important STL Algorithms

  • Non-Manipulating Algorithms
int arr[] = {10, 20, 5, 23 ,42 , 15};
int n = sizeof(arr)/sizeof(arr[0]);
vector<int> vect(arr, arr+n);
// Reversing the Vector
reverse(vect.begin(), vect.end());
cout << *max_element(vect.begin(), vect.end());//Maximum element
cout << *min_element(vect.begin(), vect.end());//Minimum element
cout << accumulate(vect.begin(), vect.end(), 0);//summation from 0
cout << count(vect.begin(), vect.end(), 20); //Counts the occurrences of 20
if(find(vect.begin(), vect.end(),5) != vect.end()){}
vector<int>::iterator it = lower_bound(vect.begin(), vect.end(), 20); //first occurrence of 20
vector<int>::iterator it = upper_bound(vect.begin(), vect.end(), 20); //last occurrence of 20
  • Some Manipulating Algorithms (permutation)
vect.erase(vect.begin()+1); //Delete second element of vector
vect.erase(unique(vect.begin(),vect.end()),vect.end()); //Deletes the duplicate occurrences, vect must be sorted
next_permutation(vect.begin(), vect.end());//modifies vector to its next permutation order
prev_permutation(vect.begin(), vect.end());modifies vector to its previous permutation order
cout << distance(vect.begin(),max_element(vect.begin(),vect.end())); //Return distance of first to maximum element
swap(x,y); //x and y are int
swap(vect1,vect2);
  • Useful Array algorithms
int ar[6] =  {1, 2, 3, 4, 5, -6};
if(all_of(ar, ar+6, [](int x){ return x>0; }))//all elements are positive
if(any_of(ar, ar+6, [](int x){ return x<0; }))//if any ele are negative
if(none_of(ar, ar+6, [](int x){ return x<0; })) //no ele is negative
copy_n(ar, 6, ar1);//copy 6 elements from ar to ar1
iota(ar, ar+6, 20); //assign 6 values to ar starting from 20 (21,22..)
  • Partition Operations
  • List of STL Algorithms

Containers

Sequence Containers: Implement data structures which can be accessed in a sequential manner.

  • vector: dynamic array capable of growing as needed to contain its elements
// init
vector<int> v;
v.push_back(1);
vector<int> v(n, 10); //n elements with value 10
vector<int> v = { 10, 20, 30 };
vector<int> v{ 10, 20, 30 };
vector<int> v(arr, arr + n); //arr is int array
vector<int> v(v1.begin(), v2.end()); //init from another vector
// common usage
cout << v.empty();
cout << v.size();
cout << v.front();
cout << v.back();
v.push_back(1);
v.pop_back(); //delete last
v.assign(5, 10); // fill the array with 10 five times
v.insert(v.begin(), 5); //insert 5 at beginning
v.erase(v.begin()); //remove the first element
v1.swap(v2); //swap two vectors
// other useage
vector<vector<int>>vv;
vector<vector<int>>vv{{}}; //push an empty vector
vv.push_back(vector<int>()); //push an empty vector
vv.push_back(vector<int>{}); //push an empty vector
vv.push_back({}); //push an empty vector
vector<vector<int>>vv(4, {}); //error
vector<vector<int>>vv(4, vector<int>()); //ok
vector<vector<int>>vv(4, vector<int>{}); //ok
//return vector
vector<int> func(){ 
    return {1,2};
    return vector<int>{1,2};
    return {};
}
// Important
if(0 < v.size() - 1)
    cout << "entered" << endl;
if vec is empty, it will enter the body, as v.size()-1 be a very large number as size() returns unsigned int. To avoid unexpected results, we can use if(0 < (int)v.size() - 1) or 0+1 < v.size().
e.g. https://leetcode.com/problems/binary-search-tree-iterator/
  • list: a doubly linked list
// init
list<int> lst;
lst.push_back(2);
lst.push_front(1); //now: 1,2
list<int> lst(10); // size 10
list<int> lst(10, 5); //10 elements with all 5
list<int> lst{4, 6, 5}; // value: 4,6,5
list<int> lst(arr, arr + n); //arr is an array
list<int> lst(lst1); //copy constructor, lst1 is another list
// common usage
cout << lst.front();
cout << lst.last();
cout << lst.size();
cout << lst.empty();
lst.push_back(1);
lst.push_front(2);
lst.pop_front(); //delete first
lst.pop_back(); //delete last
lst.erase(itr); //delete at a position
lst.clear(); //delete all elements, size 0, free memory
lst.swap(lst1); //swap elements of two lists
  • deque: double-ended queue class
// declare
deque<int> deq;
// common usage
deq.push_back(1);
deq.push_front(2);
  • arrays
// init
array<int,2> a;
a[0] = 1;
a[1] = 2;
array<int,6> ar = {1, 2, 3, 4, 5, 6};
array<int,6> ar1{2, 3, 4, 5, 6, 7};
// common usage
cout << ar.front(); //1
cout << ar.back(); //6
cout << ar[1]; //2
cout << ar.size(); //6
cout << ar.empty(); //0
for ( auto it = ar.begin(); it != ar.end(); ++it )
    std::cout << ' ' << *it; //1,2,3,4,5,6
ar.fill(0); // Filling array with 0, all elements are 0 now
ar.swap(ar1); // Swapping ar1 values with ar
  • forward_list( Introduced in C++11): implements singly linked list.
// Declare
forward_list<int> fl;
forward_list<int> fl = {10, 20, 30, 40, 50};
forward_list<int> fl{10, 20, 30, 40, 50};


// common usage
fl.assign({1, 2, 3}); // 1,2,3
fl.assign(5, 10); //5 elements with value 10
fl.push_front(10); //insert at front
fl.pop_front(); //delete frist
fl.remove(40); //Removes all occurrences of 40

Container Adaptors: provide a different interface for sequential containers.

  • queue: FIFO
// Declare
queue<int>q;
queue<int>{{1}};
//common usage
q.push(1);
q.pop();
int i = q.front();
int i = q.back();
cout << q.empty();
cout << q.size();
  • priority_queue: a type of queue where the elements are kept sorted. it can be used to create min-heap or max-heap. 
    1. top() = O(1)
    2. pop()= O(logn)
    3. push()= O(logn)
#include <queue> //not #include <priority_queue>
// declare
priority_queue<int> pq; //descending order (max heap)
priority_queue<int, vector<int>, greater<int>> pq; //ascending order (min heap)
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>> > pq; //ascending order (min heap, sorted by first element in pair)
//common usage
pq.push(10);
pq.push(30);
pq.push(20);
pq.push(make_pair(1,2)); //pair
pq.push({1,2}); //pair
cout << pq.top();//30, as it is sorted
pq.pop();
  • stack: LIFO
//Declare
stack<char> st;
stack<char> st{{'a'}};
// common usage
st.push('a');
st.pop(); //remove last element, return void. segmentation fault if empty
char c = st.top(); //return last element, segmentation fault if empty
if(st.empty()) //empty or not
cout << st.size(); //size

Associative Containers : implement sorted data structures using binary search tree that can be quickly searched (O(log n) complexity). C++’s map and set are actually ordered map and ordered set. They are not implemented using hash functions (instead red-black trees, a BST). Every query would take O(logn) and not O(1), but the values will be always sorted.

  • set: stores unique elements, with duplicate elements disallowed. The elements are sorted ( can be searched with log(n) ) according to their values. The value of the elements in a set cannot be modified once in the container (the elements are always const), but they can be inserted or removed from the container.
// init
set<int>s; //ascending order
set<int, greater<int>> s; //descending order
s.insert(1);
set<vector<int>> res; //use vector as elements, this is useful when we need a set of vector without duplicates, however, we cannot define unordered_set the same way.
// common usage
if (s.find(1) != s.end()){}
if (s.count(1)){}
cout << s.size();
cout << s.empty();
for (auto it = s.begin(); it != s.end(); it++){ //set<int>::iterator
    cout << *it << endl;
}
  • multiset: is a set where duplicate elements are allowed, it can be used to create min or max heap.
Same usage as std::set
  • map: is a set where each element is a key/value pair. The key is used for sorting and indexing the data, and must be unique. The value is the actual data. The elements in map are sorted by key.
// init
map<int, int> mp;
mp.insert(pair<int, int>(1, 40));
mp.insert(make_pair(2,3));
mp.insert({ 3, 40 });
mp[4] = 30;
map<int, int> mp1(mp.begin(), mp.end());
// common usage
cout << mp.size();
cout << mp.empty();
mp.erase(mp.begin(), mp.find(3)); //remove all elements up to element with key=3
cout << mp.erase(4); //remove all elements with key=4, returns 1 if the key element is found in the map else returns 0.
mp.clear(); //remove all elements
for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
    cout << '\t' << itr->first << '\t' << itr->second << '\n';
}
  • multimap: is a map that allows duplicate keys.
Same usage as std::map

Unordered Associative Containers : implement unordered data structures using hashing that can be quickly searched. While they are not sorted, most queries and operations are possible in O(1) averagely.

  • unordered_set (Introduced in C++11)
// init method 1
unordered_set<int> us;
us.insert(1);
// init method 2
unordered_set<int> us{1,2}; //cannot use us(1,2)
// init method 3
unordered_set<int> us{v.begin(), v.end()}; //or us(v.begin(), v.end())
// common usage
if ((us.find(1) != us.end()) // find element
if ((us.count(1)) // find element
if (us1 == us2) // check equality
for (auto it = us.begin(); it != us.end(); it++){
    cout << *it << endl;
}
  • unordered_multiset (Introduced in C++11)
  • unordered_map (Introduced in C++11)
// init method 1
unordered_map<char, int> um;
um['a'] = 1;
um['b'] = 2;
um['c']++; //if there was no key 'c', the value will be 1.
// init method 2
unordered_map<char, int> um;
um.insert(std::make_pair('a',1));
// init method 3
unordered_map<char, int> um {{'a',1},{'b',1}};
// Common usage
cout << um['a'] << endl; // 1
cout << um.empty() << endl; // 0
if ((um.find('a') != um.end()) // find element
if ((um.count('a')) // find element
auto it = um.find('a'); //or unordered_map<char, int>::iterator
cout << it->first << " " << it->second << endl; // a, 1
for(auto it = um.begin(); it != um.end(); it++){
    cout << it->first << "  " << it->second << endl;
}
  • unordered_multimap (Introduced in C++11)

Other Common Usage

The following are other commonly used tricks / tips in a coding interview.

Variable declarations, definitions, etc.

Char

// uppercase to lower case
char lower = upper + 'a' - 'A'; // or upper+32
// lowercase to upper
char upper = lower - ('a' - 'A'); // or lower-32
char c = 'A';
cout << (char)toLower(c); //a, if without char, 97 #include<cctype>
cout << isalnum(c); //1, #include<cctype>
// Toggle case
char a = 'a', b = 'B';
a ^= (1<<5);
b ^= (1<<5);
cout << a << " " << b; // A b

Integer

// negative integer
int n = -12;
cout << n / 10 << ", " << n % 10; // -1, -2
// reverse integer
int ret = 0;
while(n){
    ret = ret*10 + n%10;
    n /= 10;
}

String

// find index of char
size_t index = str.find('?');
if(index != string::npos){}
// link string with char
string s = "Abc";
string s1 = "test";
string s2 = s1 + s[0]; // s2 is testA, no explicit type cast required
string s3 = s[0]; // error
string s4 = static_cast<string>(s[0]); // error
string s4 = (string)s[0]; //error
string s5{s[0]}; // error
string s6(s[0]); // OK

std::ostringstream

// instead of using std::string to add strings for output, we can use ostringstream.
std::ostringstream oss;
oss << "test" << 123 << std::endl;
std::cout << oss.str();

Exception

try {
    if (n < 0)
        throw std::runtime_error("Bad things happened");
}        catch (const std::exception& e) {
    assert(std::string(e.what()) == std::string("Bad things happened"));
}

priority_queue (3 ways of creating min-heap)

// 1. comparison using struct to create min-heap
struct compare
{
    bool operator()(const pair<int,pair<int, int> >& a, const pair<int,pair<int, int> >& b)
    {
        return a.first>b.first;
    }
};
priority_queue< pair<int,pair<int, int> >, vector<pair<int, pair<int, int> > >, compare > p;
// 2. comparison using function to create min-heap
auto comp = [](ListNode* a, ListNode* b) { return a->val > b->val; };
priority_queue<ListNode*, vector<ListNode*>, decltype(comp)> pq(comp);
// 3. using std::greater<T> to create min-heap
priority_queue<int, vector<int>, create<int>> pq;

Reverse linked list (three pointers required)

//iterative
ListNode *current, *prev, *next;
current = head; // or current = *pointerToHead
prev = nullptr;
while(current)
{
    next = current->next; //we can define next as tmp here as well
    current->next = prev;
    prev = current;
    current = next;
}
//current, next are nullptr now
head = prev; // or *pointerToHead = prev
//recursive
ListNode* reverseList(ListNode* head) {
    if(head == nullptr || head->next == nullptr) return head;
    ListNode *node = reverseList(head->next);
    head->next->next = head;
    head->next = nullptr;
    return node;
}

Delete a node in linked list (two pointers required)

void Delete(int n) //delete n-th node
{
    Node* temp1 = head; // or ListNode* temp1 = *pointerToHead
    if (n == 1){
        head = temp1->next; // head now points to the second node, or *pointerToHead = temp1->next;
        delete temp1;
        return;
    }
    for (int i = 0; i < n - 2; i++){ // temp1 points to n-1 th node, delete temp1->next
        temp1 = temp1->next; 
    }
    ListNode* temp2 = temp1->next;
    temp1->next = temp2->next;
    delete temp2;
}

Explanation of keywords

static

  • Static variables: variables in a function, variables in a class
  • Static members of class: Class objects and functions in a class
  • Make variable declared outside of a function to have internal linkage (can only be used in that file)
static int a = 0; //internal linkage
int myFun(){
    static int b = 0; //static variable in a function, same life time of global variable
}
class Example{
    static int c; //static memeber variable, not belong to any object
    static void myFunc(); //static member method, can only call other static members
}
int Example::c = 1; //have to define outside
static Examlae example; //similar to static variable, have a scope till the lifetime of program

extern

  • Used to make const variables declared outside of a function to have external linkage (can be used in other files). In other words, it is used to extend the visibility of variables/functions.
  • It can also mean “this is a forward declaration for an external variable that is defined somewhere else”.
extern int var = 0; //define var, it can be used by other files, extern keyword can be omitted here.extern int var; //forward declaration

using

  • Import namespace: using namespace std;
  • Used for type alias is identical to typedef. e.g.using T = int;
  • Change an inherited member’s access specifier in the derived class.
class Base
{
protected:
    void printValue() { std::cout << "base"; }
};
class Derived: public Base
{
public:
    // Base::printValue was inherited as protected, so the public has no access
    // But we're changing it to public via a using declaration
    using Base::printValue; // note: no parenthesis here
};

override

  • Use override specifier for each override function in the derived class to ensure you’ve actually overridden the function you think you have.
class A
{
public:
    virtual const char* getName1(int x) { return "A"; }
    virtual const char* getName2(int x) { return "A"; }
    virtual const char* getName3(int x) { return "A"; }
};
 
class B : public A
{
public:
    virtual const char* getName1(short int x) override { return "B"; } // compile error, function is not an override
    virtual const char* getName2(int x) const override { return "B"; } // compile error, function is not an override
    virtual const char* getName3(int x) override { return "B"; } // okay, function is an override of A::getName3(int)
};

final

  • The final specifier can be used to make a virtual function no longer overridable. To prevent inheriting from a class, the final specifier is applied after the class name.
class B : public A
{
public:
    // note use of final specifier on following line -- that makes this function no longer overridable
    virtual const char* getName() override final { return "B"; } // okay, overrides A::getName()
};

class C : public B
{
public:
    virtual const char* getName() override { return "C"; } // compile error: overrides B::getName(), which is final
};
// to prevent inheriting from class A
class A final
{
}

auto and decltype

  • auto keyword specifies that the type of the variable that is being declared will be automatically deducted from its initializer.
  • decltype lets you extract the type from the variable, so decltype is sort of an operator that evaluates the type of passed expression.
auto x = 4; //x is of type intdecltype(fun1()) x; // type of x is same as return type of fun1()

explicit: to prevent converting constructors.

MyString mine = 'x'; //implicitly convert 'x' to MyString if there is a proper constructor, say: MyString(int x).
explicit MyString(int x) {
    m_string.resize(x);
}
MyString mine = 'x'; // compile error, since MyString(int) is now explicit and nothing will match this

delete

  • Similar purpose as explicit to prevent converting constructors.
MyString(char) = delete; // any use of this constructor is an error
MyString mine('x'); // compile error, since MyString(char) is deleted
  • Hide functionality that exists in the base class, so that it can not be accessed through the derived class.
class Derived : public Base
{
public:
    int getValue() = delete; // mark this function as inaccessible, note that the Base version of getValue() is still accessible though
};
  • Delete dynamically allocated memory (return to OS).
int* array = new int[10];
delete[] array;
int* ptr1 = new int;
delete ptr1;

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • C++面试准备[关闭](C++ interview preparation [closed])
    问题 就目前而言,这个问题不适合我们的问答形式。 我们希望答案得到事实、参考或专业知识的支持,但这个问题可能会引起辩论、争论、投票或扩展讨论。 如果您认为此问题可以改进并可能重新打开,请访问帮助中心以获取指导。 9年前关闭。 我接下来要与一家从事金融软件行业的公司进行电话面试。 面试主要是 C++ 和问题解决和逻辑。 请告诉我这次面试的准备方法。 我已经开始浏览 C++ 中的思考并复习概念。 有没有其他方法可以准备?? 请帮忙。 编辑: 谢谢大家的建议。 我只想补充一点,我目前刚从研究生院毕业,之前没有任何经验。 那么你能建议一些新毕业生会被问到的问题吗?? 回答1 确保您了解基本的数据结构和算法。 你更有可能被问到这些东西,而不是食物链上层的东西。 这些通常会被保存以供面对面的采访。 换句话说:扎实基础和扎实您的 C++ 语法。 此外,了解 STL 和 Boost 等常用库也无妨……但请确保您知道这些库为您提供了什么! 最终,手机屏幕是用来剔除不会做基础的人的。 证明你可以,你应该继续下一步。 祝你好运! 以下是一些面试问题的链接,供您查看: C++ 面试题 @ DevBistro C++ 面试题@Blogspot C++ 面试题@ FYI Center Steve Yegge 的五个基本电话屏幕问题(添加此内容是对您的编辑的回应。这不仅仅是 C++,但其中很多都适用于 C++
  • 作为一个Android程序员,面试字节跳动Android工程师该怎么准备?真香
    大家应该看过很多分享面试成功的经验,但根据幸存者偏差的理论,也许多看看别人面试失败在哪里,对自己才更有帮助。 最近跟一个朋友聊天,他准备了几个月,刚刚参加完字节跳动面试,第二面结束后,嗯,挂了… 所以啊,不管怎么样,不论是什么样的大小面试,要想不被面试官虐的不要不要的,只有刷爆面试题题做好全面的准备,当然除了这个还需要在平时把自己的基础打扎实,这样不论面试官怎么样一个知识点里往死里凿,你也能应付如流~ 面试前 如何寻找一个面试机会? 内推:首先推荐大家走内推途径,内推的简历通过率远高于其他方式;内推的途径有:联系工作的师兄师姐、在论坛上找对应的内推贴、参加校招宣讲会 等对应公司招聘官网直接投递:需要大家明确自己想投哪些公司,直接搜索公司的官方招聘官网(大公司普遍都有),找到自己想投的岗位投递相关招聘网站投递:在各类招聘网站上HR也会发布对应招聘信息,可以对应的投递 需要为面试做哪些准备? 一份优秀的简历:要能说明 学校、学历、实习经历、在校期间技术项目经历 等,具体的在姊妹篇《校招啦——来自字节跳动面试官的技术简历指南》,敬请期待。了解投递的岗位要求:就是我们常说的JD(Job Description),公司的招聘官网或发布的招聘信息里面会详细描述,如果找不到或公司没写,可以联系HR发邮件说明。复习面试岗位相关知识:校招同学需要复习 计算机基础(网络、操作系统、计算机组成原理
  • C++秋招知识点总结
    先介绍下本人的情况,本人研究生双非院校,本科也是普通二本,也无实习无项目非科班出生。刷了将近半年的题和自学了相关知识点,最终拿到华为、海康、大华、同花顺、深信服、CVTE、紫光展锐offer。本人主要投递的岗位是C++相关的软件开发及后端开发。本文为2021级秋招经验,主要介绍相关知识点及面试经验,包括C++语法、数据结构、操作系统、计算机网络、数据库及设计模式等高频知识点。 先讲讲本人的学习路线及各大公司推荐学习路线。本人可以说是非常的惨了,前几届师兄都是非研发岗,一点面试研发岗的经验都没有,什么实习的更别提了。本人的主要学习内容是Leetcode从第一题刷到150题,剑指offer刷完;在专业知识点方面只看了本文总结的高频知识点。在这里做个申明,如果同学不想进互联网大公司,只想进上面说的厂或者其他非互联网公司,那么你可以按照本人的学习路线走一遍,因为基本上上述内容用于非互联网公司的笔试和面试都够了。接下来聊聊双非院校同学想进BAT或者其他互联网大公司的见解和学习路线,双非院校的同学想进互联网大厂还是有一定难度的,不过功夫不负有心人,有付出就会有收获。双非院校同学进互联网大厂最好的路线就是提前准备,在研二上学期先去华为这样的大厂实习,等研二下的时候通过笔试和面试拿到互联网大厂的暑期实习offer,到时候直接转正结束秋招。说了这么多现在聊聊BAT互联网大厂的学习路线
  • Github上开源的程序员面试项目,斩获offer必备!
    CS-Notes(Interview-Notebook) https://github.com/CyC2018/CS-Notes 技术面试需要掌握的基础知识整理,主要总结一些比较重要的知识点,笔记不是从网上到处复制粘贴拼凑而来,虽然有少部分内容会直接引入书上原文或者官方技术文档的原文,但是没有直接摘抄其他人的博客文章。这是中山大学郑永川构建了一个准备秋招的项目,该项目包含了九大模块,从算法到操作系统、网络、面向对象以及数据库、Java、分布式、工具、编码实践。 Java-Guide https://github.com/Snailclimb/Java-Guide Java面试通关手册(Java学习指南),该文档主要是创建者在学习Java的过程中的一些学习笔记,但是为了能够涉及到大部分后端学习所需的技术知识点我也会偶尔引用一些别人的优秀文章的链接。 该文档涉及的主要内容包括: Java、 数据结构与算法、计算机网络与数据通信、 操作系统、主流框架、数据存储、架构、面试必备知识点等等。 advanced-java https://github.com/doocs/advanced-java 互联网 Java 工程师进阶知识完全扫盲 本系列知识出自中华石杉,对这部分知识做了一个系统的整理,方便学习查阅。By the way,微信公众号石杉的架构笔记(id:shishan100
  • LeetCode【力扣】每天刷题计划/进度
    文章目录 刷题顺序应该掌握三点数据结构算法其他知识 刷题技巧第一遍第二遍第三遍第四遍 建议腾出固定时间在线编写 总结博主后话 首先刷题贵在坚持,每天训练 保持头脑 + 回顾多想——即刻畅通.不能为了刷题而刷题,要结合实际的理论\面试[应用] 知识去刷题.并且时常总结、时常回顾. 刷题顺序 leetcode上刷刷题(多刷easy和middle难度的) ArrayStringMathTreeBacktrackingDynamic ProgrammingLinkedListBinary SearchMatrixDFS & BFSStack & PriorityQueueBit ManipulationTopological SortRandomGraphUnion FindTrieDesign 参考->Leetcode分类顺序表 应该掌握三点 数据结构 数据结构(低级的):数组,链表,栈,队列,树,图,堆,HashTable等 数据结构(高级的,本科基本学不到):线段树,树状数组,并查集,字典树等 算法 算法(低级的):排序算法(八种),DFS,BFS,二分查找,回溯,分治,递归,动态规划,拓扑排序,贪心等算法(学校学不到的):Sliding window,扫描线算法(图形学),蓄水池算法,flood fill(图形学)等更难的其实也涉及到很多:KMP,马拉车等 其他知识
  • 安卓工程师面试题,最全Android面试知识点梳理,深度解析,值得收藏
    前言 再过几个月就到了毕业季,越来越多的00后就会加入到求职找工作的大潮中,而身为30岁的你是否感到了彷徨与压力……是否也能成为新机遇下的弄潮儿。 本文将从以下方面为大家详解热修复技术: 什么是热修复?热修复的优势和不足?热修复框架分类技术原理及特点实际案例解析热修复技术选择 1、什么是热修复? 热修复就是通过下发补丁包,让已安装的客户端动态更新,用户不用重新安装APP,就能够修复软件缺陷。 2、热修复的优势和不足? 优势: 无需重新发布版本;用户无感知修复,代价小;修复成功率高,把损失降到最低。 不足: · 补丁只能针对单一客户端版本,随着版本差异变大补丁体积也会增大; · 补丁不能支持所有的修改,例如AndroidManifest; · 补丁无论对代码还是资源的更新成功率都无法达到100%。 3、常用热修复框架 简单分类如下: 合理的分类如下: 4、技术原理及特点 native解决方案; Dex插桩方案(大众点评的Nuwa参考其实现并开源); Instant Run 热插拔原理等; 5、实际案例解析 QQ空间; 微信热补丁方案: 美团Robust等; 6、热修复技术如何选择? 1、阿里Dexposed 2、阿里AndFix 3、QQ空间 4、美团Robust 5、微信Tinker 6、阿里Sophix 如何做好面试突击,规划学习方向? 面试题集可以帮助你查漏补缺
  • 31道Android面试题,Android程序员面试必备的知识点,已开源
    咸鱼翻身不断上演 2018年5月份,北京,在所谓的互联网寒冬里,一个普通二本的学生,在小公司工作一年后,跳槽拿到了百度的offer,月薪从9k变为17k,涨薪幅度接近100%。 2018年底,上海,一个只有高中学历的同学,通过培训加入了IT行业,刚开始他的月薪只有6k,一年后,他的月薪变为了16k,涨幅接近167%。 2019年3月,北京,一个xx科技学院毕业的的普通二本,在小公司跌跌撞撞半年后,今年年初突然开挂,成功拿到了百度、小米、网易和头条的offer,最终他选择了多金的头条,拿到了近30k的月薪。 2020年初,深圳,一个物理专业毕业的研究生,在工作短短两年后,拿到了年薪50万的offer,现在已经是高级工程师了。 像这样的例子还有很多,无法一一列举,可见,没有名校学历和耀眼的光环,照样可以进入大厂拿高薪,只是很多人没有领悟要领而已。 打铁还需自身硬 其实,对于学历普通也没有耀眼光环的人来说,进大厂就靠一条,那就是:技术实力。但是很多人在小厂待习惯了,总是用小厂的标准来衡量大厂的要求,屡次面试受挫,于是得出了一个结论:面试造飞机,入职拧螺丝钉。 但事实上,大厂的平台更大,用户量也更多,自然技术要求也更高,不能完全用拧螺丝钉来形容。就算大厂做的也是普通的事情,但是很多时候,大厂对稳定性、执行效率和崩溃率的极致追求,都是在小厂无法体会的。 我们知道,一件看似简单的事情
  • C++后台开发学习路线
    C++后台开发学习路线 2.1 如何拿下BAT:我的学习路线 前言 **2019年对我而言必定是人生当中最重要的一年。因为实习的原因,我第一次体验了北京和上海的生活,匆匆且忙碌。这一年生活当中充斥着各种求职咨询,面试,做题,仿佛一夜回到了高三。不过,我是幸运的。从寒假实习开始到暑假实习再到秋招,一路以来我并没有体会到太多的挫折,一路高歌,最终也收获了我自己认为还不错的offer。也许是因为运气,也许是因为坚持,但是硕士这2年来我也经历了种种心酸和波折。我起初走过很多弯路,在无数个深夜里苦恼自己的无知和弱小,曾跌入低谷,连续数天的低沉,最终慢慢调整,告诉自己不能松懈,直到现在… ** 我希望可以把我从实习到秋招这一路以来的体会和经历分享给大家。作为一个还没有正式进入公司的在校学生,我在技术上还是一个实打实的”菜鸟“,但是作为一个应届求职者,我是"专业的"。本节我将从面经积累,价值观以及学习路线这三个角度介绍我的经验。 面经积累 我有一个习惯,就是记录和整理知识。从春招实习开始,我每一次面试都会录音,事后都会复盘。所有的面试记录,面试官问的问题,手写的算法题以及我个人面试的感受我都会记录下来。看过《深入理解计算机系统》的小伙伴都应该知道程序的执行是有空间局部性和时间局部性,其实面试官考察的知识点的范围也是如此。当你多次遇到同一个问题的时候就应该去把它记录下来。与其面对茫茫多的知识
  • 胡神CS学习经验贴
    文章核心是学习方式,可以页面搜索——学习方式 关键字。 本文转自一个浙大17级学长胡神在github上的CS学习经验贴,真滴强!!学习的榜样。 光是膜没意义,要行动。 附:该学长的学习笔记https://github.com/huangrt01/CS-Notes 对本文很深刻的一点是,胡神一开始学CS: “因为周围没有认识学CS的人,就去看知乎上大家的推荐,大家都推荐从SICP和CLRS入门,于是我就去看SICP和CLRS并努力做习题,而且当时太年轻,看的还是翻译版的。看到后面怀疑自己完全就是弱智,别人的入门书我怎么就学不懂呢… 其实有几个原因,一方面是这两门书挺难的,不见得适合入门;另一方面是翻译版翻译得也不是很好。可以说自己刚开始学CS的时候走了不少弯路。后来看到Coursera上有开Princeton的Algorithm课,就去把那个课跟了一遍,完成了习题。 这时候才终于感觉原来自己还是能学会一些东西的:) 又把Edx上MIT的6.001x跟完了,还看了一些Harvard的CS50课程的内容,这时候终于感觉自己算是开始学CS了。” 写在20年初的校招面试心得与自学CS经验及找工作分享 我于大三(15年下旬)开始自学CS,并在去年(19年)参加了校招的实习与春招,很幸运地拿到了10来家公司的offer。在这里分享一下自己总结的面试心得与技巧、自学CS的方法与资料
  • 【Github】NLPer-Interview: NLP 算法工程师相关的面试题
    周末推荐一下老宋同学整理的Github项目:songyingxin/NLPer-Interview ,该仓库主要记录 NLP 算法工程师相关的面试题:https://github.com/songyingxin/NLPer-Interview老宋目前是百度算法工程师,也是知乎老宋的茶书会专栏作者,以下主要来自老宋对该仓库的描述,点击"阅读原文"直达该仓库主页面,推荐Star,内容相当丰富。本仓库主要记录本人对 NLP 相关知识的积累,之前笔记做的很多,考虑到秋招已至, 在复习的过程中, 慢慢将这些知识屡清楚,然后将相关的知识笔记整理成专题,来帮助我更好的复习。同时,开源出来,希望大家能帮助我补一补相关的技术栈,看看我哪方面比较弱,同时也帮助诸位秋招中的伙伴更好的复习。如果希望一起做的同学,可以联系我, 毕竟一个人做这么多,的确有点难,还好我前期笔记做的比较全。推荐使用 Typora 编辑器打开, 所见即所得。Contents1. 编程语言基础该文件夹下主要记录 python 和 c++ 的一些语言细节, 毕竟这两大语言是主流,基本是都要会的,目前还在查缺补漏中。C++面试题Python 面试题2. 数学基础该文件夹下主要记录一些数学相关的知识,包括高数,线性代数,概率论与信息论, 老宋亲身经历,会问到, 目前尚在查缺补漏中。概率论高等数学线性代数信息论3
  • 前端最强面经汇总
    花了很长时间整理的前端面试资源,喜欢请大家不要吝啬star~ 别只收藏,点个赞,点个star再走哈~ 持续更新中……,可以关注下github 项目地址 https://github.com/abc-club/free-resources/blob/master/INTERVIEW.md 求star!!! 求star!!! 求star!!! 面试秘籍 中高级前端大厂面试秘籍,为你保驾护航金三银四,直通大厂(上)前端面试 - 收藏集 - 掘金2万5千字大厂面经前端面试之道 面试题集 前端开发面试题前端 100 问:能搞懂 80% 的请把简历给我前端面试每日 3+1 —— 第61天这儿有20道大厂面试题等你查收【周刊-1】三年大厂面试官-面试题精选及答案【周刊-2】三年大厂面试官-前端面试题(偏难)【周刊-3】三年大厂面试官-十道前端面试题(欢迎挑战)Flutter 面试知识点集锦面试必备的13道可以举一反三的Vue面试题2018前端面试准备史上前端面试最全知识点(附答案)以面试官的角度来看 React 工作面试jsliang 的 2019 面试准备总结了17年初到18年初百场前端面试的面试经验(含答案)2019 前端面试 | “HTML + CSS + JS”专题面试30秒(含答案)五年面试,三年模拟面试的信心来源于过硬的基础面试分享
  • 2021年刚启程 字节/阿里/ 百度 相继发布薪资总包 40w 优质Java岗面试题合集
    2021刚刚启程,各互联网大厂便发布了一大波优质Java岗,平均薪资总包都在40w左右,你心动了吗?下面给大家列出几个具体的岗位及要求。 此外,在文末还有分享:由各大厂面试官整理的字节、阿里、百度Java内部面试题(含答案),新鲜出炉!希望大家了解并掌握这些知识点,争取通过每一轮面试! 字节跳动Java 开发工程师 薪资:25~40k 16薪 扎实的计算机基础知识,较强的逻辑理解能力和学习能力熟悉python、php、C++、java、golang中的至少一门语言,java背景优先熟悉Mysql 、Memcache、Redis、消息队列等常用服务组件,有定制化改进经验者优先有较强软件架构设计能力,较强的代码优化能力熟悉互联网架构体系,对微服务拆分、服务治理、负载均衡、流控等有较好的理解和实践积极主动、自驱力强,深入了解业务并与业务中各角色建立沟通,能独立负责一块业务,迅速推进项目与问题的解决 阿里巴巴Java技术专家 薪资:30~50k 16薪 扎实的JAVA基础,熟练掌握JVM、并发编程、网络编程等基础知识;精通 Spring,MyBatis,RPC等流行开源框架;掌握常用数据结构、常见设计模式,拥有领域模型抽象能力;熟练掌握分布式系统的设计与应用,深入理解常用开源中间件的实现原理,知其然知其所以然;具有大型分布式、高并发、高负载、高可用性系统设计开发维护经验
  • Java知识体系最强总结(2020版)
    Java知识体系最强总结(2020版) 原创ThinkWon 最后发布于2019-12-18 10:09:56 阅读数 188659 已收藏 展开 更新于2020-03-14 18:00:00 本人从事Java开发已多年,平时有记录问题解决方案和总结知识点的习惯,整理了一些有关Java的知识体系,这不是最终版,会不定期的更新。也算是记录自己在从事编程工作的成长足迹,通过博客可以促进博主与阅读者的共同进步,结交更多志同道合的朋友。特此分享给大家,本人见识有限,写的博客难免有错误或者疏忽的地方,还望各位大佬指点,在此表示感激不尽。 整理的Java知识体系主要包括基础知识,工具,并发编程,数据结构与算法,数据库,JVM,架构设计,应用框架,中间件,微服务架构,分布式架构,程序员的一些思考,项目管理,运维,权限,推荐书籍,云计算,区块链等,包含了作为一个Java工程师在开发工作学习中需要用到或者可能用到的绝大部分知识。千里之行始于足下,希望大家根据自己的薄弱点,查缺补漏,根据自己感兴趣的方面多学习,学的精通一点,从现在开始行动起来。路漫漫其修远兮,吾将上下而求索,不管编程开发的路有多么难走,多么艰辛,我们都将百折不挠,不遗余力地去追求和探索。 文章目录 Java面试总结基础知识 Java概述基础语法面向对象集合框架IO流网络编程常用API常用工具类库单元测试异常日志工具
  • GitHub 上标星 98.1k《JavaGuide 面试突击版 V4.0》来啦!BAT通关手册,厉害!
    最近,由于公司项目比较忙,没能来得及整理学习资料,基本上都是996的工作方式,但粉丝朋友也不能落下。为此,特地整理了一份 GitHub 上标星 98.1k《JavaGuide 面试突击版 V4.0》来啦!BAT通关手册,厉害! 其实,通过写作和技术分享,猿人结交了不少朋友,包括在校大学生,同行朋友,以及想让我帮忙做私活的朋友。在力所能及的范围内,猿人尽可能的帮助大家,无论是技术、职场、私活等,搞技术是枯燥无味的,但能和一群志同道合的朋友一起交流技术,一起学习,一起成长,也是一件非常开心的事情。 以下是和结交的粉丝朋友们的聊天记录,感觉还是挺有意义的,希望以后有需要猿人帮助的朋友,不妨大胆一些,我们也许现在并不相识,你现在也许正在上大学,感觉前途很迷茫;你现在也许刚参加工作,还是职场小白;你现在也许不是在互联网行业,想转行做互联网;你现在也许有项目,找公司做报价太高,超出了预算,想找个靠谱的人帮忙做;你现在也许想学习Java,但没有思路,不知道如何学;你现在也许…这一切的一切都没事,我们可以一起学习,一起成长,一起合作。学习工作的路上有一群志同道合的朋友,一起前进,也是很有趣的事。 2021 年的 1 月份,朋友的《JavaGuide 面试突击版》V4.0 版本更新了,我第一时间就拿到了离线版(文末有提供下载地址),不得不说,阅读体验比之前的版本更舒服了,简直有点爱不释手。
  • 实践出真知!史上最全的Android面试题集锦,offer拿到手软
    一、前言 本人面试已经很久之前了,分享一下我做美团面试官的经历吧。 美团上海面试,2-1及以下美团是不社招的,校招和2-2~2-3社招一般是三面,格外优秀3-1及以上会加签面试。初面技术基础,二面业务感知和技术项目,技术设计等。三面 HR面。 初面一定要准备相对较多的基础知识,简历上的东西一定是熟悉的,自己的知识也不能落伍。会有一些简单的算法题。二面主要是项目设计,项目设计的背景,目标,执行中的问题,最后的结果都要非常清楚。三面 HR 面试还是比较大陆货,主要打探职级,绩效评价一个人的工作努力程度,岗位适配程度等。 阿里面经 面试形式是电话面试,算法是面试官会给你邮箱发一个链接,然后在那个网站里面就可以同步共享屏幕,网站类似于一个编辑器,不能编译,写了代码面试官会看,交流还是在电话里面完成。 一面(1小时) 重载与重写 final修饰符 抽象类和接口 GC机制、原理 finalize( )的理解 GC机制如何判定哪些对象需要回收 GCRoots有哪些 四种引用 垃圾收集算法 Hash Map与Hash table的区别 怎么让Hash map线程安全 Thead Loocal了解吗? 线程同步的几种方式 加锁与synchromized区别 Volatile 了解吗 JVM内存模型 leakCanary内部机制 Handler内部机制 MNC与MVP的区别
  • LeetCode高效率刷题指南、刷题顺序、技巧和进一步提升方法
    首先,刷题是为了了解思路;然后,其次才是语言,进行实现;最后,不能一遍就算了 要反复刷且学会刷题。 有总结、坚持和结题指南的输出。 在前文基础上新增一些想法: 刷题思路 —— 大厂攻略 前言 python 链接刷题顺序——按照 一个类型刷:https://github.com/huxiaoman7/leetcodebook 400道题目 提升精简版本 - 250题目 PS. ①分享一些计算机的经典书籍,大部分对面试应该都有帮助,强烈推荐 🌝 我看过的 100 本书 ② 重点250题——二刷时候看;注意总结模板。 刷题模板和套路总结 刷题是为了思维不易望。全面总结 并 掌控算法。 算法套路F*cking[5] fucking-algorithm[1] 对 Leetcode 上的题型进行了全方位的总结解析,对同类型的题总结了算法思维,举一反三,仔细研读一下这篇笔记,找工作再也不会被算法题难到,像作者所说的,“「感受一下支配算法的乐趣」“。 这个开源项目一共分为六章,G 哥简单概括了一下项目所涵盖的内容: 「必读系列」 :作者从大的框架思维出发,介绍了动态规划解题框架、回溯算法解题框架、二分查找、滑动窗口解题框架、双指针技巧解题框架等,全是 Leetcode 题型网红款。作者对这些题型的解题框架进行了详细的总结,让读者从一开始就对整体的解题思路有一个清晰的认识,在后面的章节中
  • 恐怖:简直把所有Java知识面试题写出来了
    前言 作为一个 Java 程序员,你平时总是陷在业务开发里,每天噼里啪啦忙敲着代码,上到系统开发,下到 Bug 修改,你感觉自己无所不能。然而偶尔的一次聚会,你听说和自己一起出道的同学早已经年薪 50 万,而自己却囊中羞涩。于是你也想看看新机会,找个新平台,好好发展。 但是面试的时候,当那个笑眯眯的面试官问出那些你再熟悉不过的 Java 问题时,你只是感觉似曾相识,却怎么也回答不到点上。比如 HashMap 的工作原理,再或者 volatile 的使用场景。 这个时候,你可能会怀疑自己的能力,也痛恨为什么当初自己没有好好复习。 该新版文档在Github上上传一个星期已经收获30K+star的Java核心面试神技(这参数,质量多高就不用我多说了吧)非常全面,包涵Java基础、Java集合、JavaWeb、Java异常、OOP、IO与NIO、反射、注解、多线程、JVM、MySQL、MongoDB、Spring全家桶、计算机网络、分布式架构、Redis、Linux、git、前端、算法与数据结构、MyBatis、RocketMQ、Netty、Dubbo、Zookeeper、分布式缓存、数据结构等等内容非常丰富,已经帮很多人拿下互联网一线公司的offer。下面我来跟大家一起分享一下。 - JavaOOP 什么是B/S架构?什么是C/S架构 Java都有哪些开发平台?什么是JDK?什么是JRE
  • 程序员面试什么最重要?
    程序员面试什么最重要?程序员面试一直是社区乐于讨论的热门话题。我自己从06年实习以来,先后经历了4家软件公司,全部是外企,其中有世界500强的通信企业,有从事期权期货交易的欧洲中等规模的金融公司,也有为大型汽车制造商开发Android智能汽车的新兴公司。跨入IT行业以来,我在求职过程中经历过多次面试,最近两年也有过多次面试别人的经验。我感觉现在到了对这个问题发表自己看法的时候,这篇文章是我站在面试官角度对于程序员面试问题的一个阶段性反思和经验总结。目标相信和不少朋友一样,有了几年工作经验成为Senior后就开始了面试别人的经历。我在最初这个阶段只是按照自己的想象把”找到基础好的程序员“,”找到算法能力优秀的程序员“,”找到有Android开发经验的程序员“等作为面试的目标。但是,实际的经历告诉我,尤其是按“基础好”,“算法好”这些目标招到的人最终效果并不好。比如,有的面试者基础知识和算法掌握情况不错,进程、线程、内存等概念清晰,基本的Hash,二叉树,快速排序等数据结构和算法也比较熟悉,但是进公司后在实际工作中表现得很糟糕。后来,我才发现原来是我的面试目标出了问题,我原先的面试方法更像是大学的算法或操作系统期末考试,按照这种方法让许多并不合适的人通过了面试,同时也可能错过了许多合适的人。后来,我的反思是,从公司的角度讲,面试的根本目的是找到"能够干好工作"的人,而“高学历”,
  • 《HelloGitHub》第 21 期
    公告元旦快乐!《HelloGitHub》第 21 期兴趣是最好的老师,HelloGitHub 就是帮你找到兴趣!简介分享 GitHub 上有趣、入门级的开源项目。这是一个面向编程新手、热爱编程、对开源社区感兴趣 人群的月刊,月刊的内容包括:各种编程语言的项目、让生活变得更美好的工具、书籍、学习笔记、教程等,这些开源项目大多都是非常容易上手,而且非常 Cool。主要是希望大家能动手用起来,加入到开源社区中。会编程的可以贡献代码不会编程的可以反馈使用这些工具中的 Bug帮着宣传你觉得优秀的项目Star 项目⭐️在浏览、参与这些项目的过程中,你将学习到更多编程知识、提高编程技巧、找到编程的乐趣。???? 最后 HelloGitHub 这个项目就诞生了 ????以下为本期内容|每个月 28 号发布最新一期|点击查看往期内容C 项目1、kcp:纯算法实现的快速可靠协议。能以比 TCP 浪费 10%-20% 的带宽为代价,换取平均延迟降低 30%-40%,且最大延迟降低 3 倍的传输效果C++ 项目2、OpenCC:中文简繁转化开源项目,在线尝试严格区分 “一简对多繁” 和 “一简对多异”完全兼容异体字,可以实现动态替换严格审校一简对多繁词条,原则为 “能分则不合”支持异体字和地区习惯用词转换,如 “裏” “裡”、“鼠標” “滑鼠”词库和函数库完全分离,可以自由修改、导入、扩展支持 C++
  • 安卓音视频开发,字节跳动Android实习面试凉凉经,年薪超过80万!
    前言 前几天去参加了一场面试。面试的题目大多很基础,有一道关于埋点的问题,面试官问我如果不用第三方SDK进行埋点,自己埋点的话,如何减少埋点对业务代码的入侵。 当时没想太多,就说创建一个 BaseView 类,在这个类中进行埋点的操作,然后使需要进行埋点操作的 View 继承这个 Base 类。后来想想,这个方案其实存在很多问题,因为让每个需要埋点的 View 去继承 BaseView 类,说明 View 需要自定义,会耗费很多的时间和精力,对于自带的 Button 等控件的埋点,这种方法又无法实现。所以说,其实在这个问题上,我答的不是很好,但可能之前的几个问题答得不错,面试官也没说什么,就说行,然后继续问下面的问题。 对于埋点,减少业务代码入侵这个问题,我回来想了想,或许用代理模式来实现,会是一个很好的选择。 第一阶段:Android 基础知识回顾: 回顾Android 开发编程,深入理解Android系统原理和层次结构,深入分析Handler源码和原理;回顾Java,C/C++,Kotlin、dart 在Android开发中必用的语言,熟悉一下几种语言混淆后的特性;回顾Android IPC和JNI的底层原理和热更新技术回顾Native开发要点,使用C++结合NDK完成Android Native开发;回顾Android开发中常用的 AMS、PMS