C++笔试中遇到的问题

   1.  sizeof与strlen的区别？

        答： sizeof是操作符，分配的数组实际所占的内存空间大小，不受里面存储内容的影响。strlen是函数，strlen计算字符串的长度，以'\0'为字符串结束标志。

输出为 ： 4    10        11    10

2. 逆序输出链表？

      答： 我们有两种办法，将链表的节点压入栈中，依次弹出，打印链表的值。第二种是用递归来实现链表的逆序输出。

3.判断链表是否有环？

     答： 判断一个链表是否有环，定义两个指针，让一个走一步，一个走两步，如果有环，走两步的肯定会追上走一步的，所以，写下如下代码：

4. 地上有m行n列的方格，一个机器人从坐标(0,0)的格子开始移动，它的每一次可以左、右、上、下 移动一格，但不能移动到行坐标和列坐标的数位之和大于k的格子?

  答： 典型的回溯法例题，机器人从（0,0）开始移动，当他准备进入坐标(i,j)的格子时，通过检查坐标数位和来判断机器人是否能够进入，当机器人能够进入坐标为（i, j）的格子，在判断它能够进入四个相邻的格子（i,j-1）(i-1,j) 、（i,j+1）,(i+1,j的格子

//这个函数是用来解决这个问题的函数
int movingCount(int k, int rows, int cols)
{
	bool *visited = new bool[rows*cols];   //用来判断所有的格子是否走过
	for (int i = 0; i < rows*cols; i++)
		visited[i] = false;               //全部赋值为false,也就是没走过
	int count = movingCountCore(k, rows, cols, 0, 0, visited);  //用来计算符合问题的格子数目
	delete[] visited;                     //释放开辟的内存
	return count;
}
//用这个函数来计算格子的数量
int movingCountCore(int k, int rows, int cols, int row, int col, bool* visited)
{
	int count = 0;
	if (check(k, rows, cols, row, col, visited))    //检查是否满足条件
	{
		visited[row*cols + col] = true;             //满足的话，就当前格子赋值为true，也就是走过
		count = 1 + movingCountCore(k, rows, cols, row - 1, col, visited)
			+ movingCountCore(k, rows, cols, row , col-1, visited)
			+ movingCountCore(k, rows, cols, row+1, col, visited)
			+ movingCountCore(k, rows, cols, row, col + 1, visited);
	}
	return count;
}
//查看这个格子是否能走
bool check(int k, int rows, int cols, int row, int col, bool*  visited)
{
	if (row >= 0 && row < rows && col >= 0 && col < cols && getDigitSum(row) + getDigitSum(col) <= k && !visited[row*cols + col])
		return true;

	return false;
}
//用来计算数位之和
int getDigitSum(int number)
{
	int sum = 0;
	while (number > 0)
	{
		sum += number % 10;
		number = number / 10;
	}
	return sum;
}

    4. 2 请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。

//用来计算矩阵中是否有这条路径， 有的话true
bool hasPath(char* array, int rows, int cols, char* str)
{
	if (array == NULL || rows < 1 || cols < 1 || str == NULL)    //边界判断
		return false;
	bool *visited = new bool[rows*cols];                       //将矩阵赋值为全没走过
	memset(visited, 0, rows*cols);                             
	int pathLength = 0;
  //在原字符串矩阵中，不知道这个子字符串的开始元素，所以每个元素都得遍历
	for (int row = 0; row < rows; ++row)
	{
		for (int col = 0; col < cols; ++col)
		{
			if (hasPathCore(array, rows, cols, row, col, str, pathLength, visited))
			{
				return true;
			}
		}
	}
	delete[]  visited;            //释放内存
	return false;
}
//矩阵中查找子串路径的函数
bool hasPathCore(char *array, int rows, int  cols, int row, int  col, char *str, int pathLength, bool* visited)
{
	if (str[pathLength] == '\0')    
		return true;
	bool hasPath = false;
	if (row >= 0 && row < rows&&col >= 0 && col < cols&&array[row*cols + col] == str[pathLength] && !visited[row*cols + col])
	{
		++pathLength;
		visited[row*cols + col] = true;
		hasPath = hasPathCore(array, rows, cols, row, col-1, str, pathLength, visited) ||
			hasPathCore(array, rows, cols, row - 1, col, str, pathLength, visited) ||
			hasPathCore(array, rows, cols, row, col + 1, str, pathLength, visited) ||
			hasPathCore(array, rows, cols, row + 1, col, str, pathLength, visited);
		if (!hasPath)
		{
			--pathLength;
			visited[row*cols + col] = false;
		}
	}
	return hasPath;
}