算法题笔试知识点整理

6.快排

void qs(vector<int> array,int left,int right){
	if(left < right)
	{
		int pivot = array[left];
		int low = left, high = right;
		while(low < high)
		{
			while(array[high] >= pivot && low < high)
				high--;
			array[low] = array[high];
			
			while(array[low] <= pivot && low < high)
				low++;
			array[high] = array[low];
		}
		array[low] = pivot;
		for(int i=0;i<array.size();i++){
			cout<<array[i]<<" ";
		}
		cout<<endl;
		qs(array, left, low - 1);
		qs(array, low + 1, right);
	}
}

7.归并排序

void Merge(int arr[], int l, int q, int r){
    int n=r-l+1;//临时数组存合并后的有序序列
    int* tmp=new int[n];
    int i=0;
    int left=l;
    int right=q+1;
    while(left<=q && right<=r)
        tmp[i++] = arr[left]<= arr[right]?arr[left++]:arr[right++];
    while(left<=q)
        tmp[i++]=arr[left++];
    while(right<=r)
        tmp[i++]=arr[right++];
    for(int j=0;j<n;++j)
        arr[l+j]=tmp[j];
    delete [] tmp;//删掉堆区的内存
}
 
void MergeSort(int arr[], int l, int r){
    if(l==r)
        return;  //递归基是让数组中的每个数单独成为长度为1的区间
    int q = (l + r)/2;
    MergeSort(arr, l, q);
    MergeSort(arr, q + 1, r);
    Merge(arr, l, q, r);
    
}

8.背包问题

 public static int knapSack(int[] w, int[] v, int C) {
        int size = w.length;
        if (size == 0) {
            return 0;
        }

        int[][] dp = new int[size][C + 1];
        //初始化第一行
        //仅考虑容量为C的背包放第0个物品的情况
        for (int i = 0; i <= C; i++) {
            dp[0][i] = w[0] <= i ? v[0] : 0;
        }
		//填充其他行和列
        for (int i = 1; i < size; i++) {
            for (int j = 0; j <= C; j++) {
                dp[i][j] = dp[i - 1][j];
                if (w[i] <= j) {
                    dp[i][j] = Math.max(dp[i][j], v[i] + dp[i - 1][j - w[i]]);
                }
            }
        }
        return dp[size - 1][C];
    }

9.并查集（路径压缩）

class Solution {
public:
    int find(int x, vector<int>& pre){////找到x属于哪一个组,如果不是自成一组，在往下找pre[x]属于哪个组
        int ans=pre[x]==x ? x :  find(pre[x], pre);
        pre[x]=ans;
        return ans;
    }
    int findCircleNum(vector<vector<int>>& M) {
        if (M.size()==0)return 0;
        vector<int>pre(M.size());
        for(int i=0; i<M.size(); i++)
            pre[i] = i;//先各自为组，组名也为自己的序号
        int group = M.size();//一开始有多少人就有多少个朋友圈，当每出现一对朋友时就减1，最后就是总的朋友圈数量了。
        for(int i=0; i<M.size(); i++){
            for(int j=0; j<M.size(); j++){
                if (i != j && M[i][j] == 1){
                    int x1 = find(i, pre);//x1为i所属的组
                    int x2 = find(j, pre);//x2为j所属的组
                    if (x1 != x2){
                        //如果不属于同个朋友圈的话就把i归为j的组
                        pre[x1] = x2;
                        group--;
                    }
                }
            }
        }
        return group;
    }
};

10.真随机

srand((unsigned)time(NULL));

11.常见数据结构性能

这里的查找应该是indexof的意思

12.name的值

下面的代码会输出什么？

function A(name) {
  this.name = name || 'Tom'
  this.msg = "use 'this.' set in function"
}

function B() {};
B.prototype = A;

var b = new B();

console.log(b.name);
console.log(b.msg);

答案是：

A
undefined

分析

b.name返回 A，是因为b上面没有name属性，他就会沿着原型链向上查找，然而 b.__proto__ 为函数A，每一个函数都有一个属性为name，其值是函数的名字。

function abc() { /* 这是一个名为'abc'的函数 */ }
abc.name // -> 'abc'

b.msg 为什么是undefined哪？ 因为b.__proto__ 是 函数A，那怎么修改才能拿到msg哪？

B.prototype = new A();

修改后的输出：

Tom
VM731:12 use 'this.' set in function

14.js的map操作

获取map长度：m.size
遍历map：

for(let k of m){
	console.log(k[0],k[1]);
}

15.js的数组拷贝

newArr=oriArr.concat();

16.match与exec与test

1.reg.exec(str)
如果reg有g属性，那么每次返回的能继续上一次的位置
返回样例：

//返回值可以用下标访问不同分组
(2) ["{12}", "12", index: 0, input: "{12}{324}{2314}", groups: undefined]
(2) ["{324}", "324", index: 4, input: "{12}{324}{2314}", groups: undefined]
(2) ["{2314}", "2314", index: 9, input: "{12}{324}{2314}", groups: undefined]

2.str.match(reg)
如果没有g，每次返回都是第一个匹配对象。
如果有g，返回所有匹配的字符串（不包含分组）
3.reg.test(str)
返回值只有true和false，是最简单的正则匹配
4.replace
其中第二个参数可以是一个函数，这个函数可以拿到被替换的部分

总结

如果要对分组进行细致操作的，如获取下标或者分组，那就使用带g的exec，如果是简单的操作的，比如只要获取所有匹配字符串，那就用match
特殊几个符号
[^x]：指排除x以外的所有都可匹配
\b：单词边界，不是匹配具体字符，而是边界的位置，如果/B则是指除了单词边界之外所有字符之间的间隔

18.选择题小计

1.Infinity
Infinity与任何实数相加都为本身

19.js不常见函数

// 填充
const password = "hackme";
// ***kme
console.log(password.substr(-3).padStart(password.length, "*"))

//四舍五入
var num =2.446242342;
num = num.toFixed(2);  // 输出结果为 2.45

//字符串比较
arr1.sort((a,b) => {
	return a.localeCompare(b)
})

//arr.findIndex()以及find,返回符合条件的第一个下标
var ages = [3, 10, 18, 20];
 
function checkAdult(age) {
    return age >= 18;
}
 
function myFunction() {
    document.getElementById("demo").innerHTML = ages.findIndex(checkAdult);
}

20.为什么0.1+0.2！=0.3

因为js中小数的存储也是用二进制的，对于一些数只能取到近似值。

21.十进制转二进制、二进制转十进制

//2转10
console.log(parseInt('101',2));
//10转2
var num = 3;
console.log(num.toString(2));
//10转16
var num = 101;
console.log(num.toString(16));