笔试面试题目5

最新推荐文章于 2021-03-30 08:48:26 发布

xiao_0429

最新推荐文章于 2021-03-30 08:48:26 发布

阅读量995

点赞数

分类专栏：笔试面试知识

本文链接：https://blog.csdn.net/xiao_0429/article/details/12848419

版权

笔试面试知识专栏收录该内容

24 篇文章 0 订阅

订阅专栏

1. 删除字符分析：转自《待字闺中》

删除字符串中的"b"和"ac"，需要满足如下的条件：
  1. 字符串只能遍历一次
  2. 不能能够使用额外的空间
  例如：
  1. acbac ==> ""
  2. aaac ==> aa
  3. ababac ==> aa
  4. bbbbd ==> d
  进一步思考：如何处理aaccac呢，需要做那些改变？
思路：
  使用状态机进行处理，我们有两个状态：ONE和TWO。TWO表示，前一个字符是'a'的状态，其他的都用ONE表示。
  1. 如果当前状态为ONE，则拷贝：str[j]=str[i];但是如果当前字符满足以下两种状态中的任一个，则不进行拷贝
      a. 当前字符是'b'，因为我们要删除'b'
      b. 当前字符是'a',我们要考虑下一个字符是c
  2. 如果当前状态为TWO：
      a. 当前字符不是'c'，那么我们要首先拷贝前一个字符'a'
      b. 然后考虑当前字符，如果不是'b'或者'a'，则拷贝字符
  状态转换非常简单，就是每次都检查是前一个字符为'a',基本代码如下：

void stringFilter( char * str)
{
	// 初始状态为ONE，前一个字符不是'a'
	int state = ONE;
	int j = 0; // 初始化j为0
	
	for(int i = 0; str[i] != '\0'; i++)		
	{
		if(state == ONE && str[i] != 'a' && str[i] != 'b')	// 当前状态为ONE的情况
		{
			str[j] = str[i];
			j++;				
		}
		
		if(state == TWO && str[i] != 'c')	// 当前状态为ONE的情况
		{
			str[j] = 'a';
			j++;
			if(str[i] != 'a' && str[i] != 'b')
			{
				str[j] = str[i];
				j++;
			}			
		}
		state = (str[i] == 'a') ? TWO : ONE;
	}
	
	if(state == TWO)	// 这里容易忘记
	{
		str[j] = 'a';
		j++;
	}
	
	str[j] = '\0';
}

  进一步考虑aaccac时，最终得到ac，ac在题目中要求的也是要删除的。
  如果题目要求将所有的ac删除，则需要做进一步的处理，对上述代码做一个简单修改即可。
  在循环结束时，加入如下的代码：
  if( j > 1 && str[j-2] == 'a' && str[j-1] == 'c')
  {
      j = j - 2;
  }

例子代码：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

#define ONE  1
#define TWO  2

void stringFilter( char * str)
{
	int state = ONE;    // 初始状态为ONE，前一个字符不是'a'
	int j = 0;          // 初始化j为0

	for(int i = 0; str[i] != '\0'; i++)
	{
		if(state == ONE && str[i] != 'a' && str[i] != 'b')  // 当前状态为ONE的情况
		{
			str[j] = str[i];
			j++;
		}

		if(state == TWO && str[i] != 'c')   // 当前状态为TWO的情况
		{
			str[j] = 'a';
			j++;
			if(str[i] != 'a' && str[i] != 'b')
			{
				str[j] = str[i];
				j++;
			}
		}
		state = (str[i] == 'a') ? TWO : ONE;

		// 根据题目要求，删除后再次组成ac是否需要删除
		if( j > 1 && str[j-2] == 'a' && str[j-1] == 'c')    // 删除后前后字符又组成了ac组合
		{
			j = j - 2;
		}
	}

	if(state == TWO)	// 这里容易忘记
	{
		str[j] = 'a';
		j++;
	}

	str[j] = '\0';
}

int main()
{
	char str[] = "acbac\0";
	cout << str << " ==> ";
	stringFilter(str);
	cout << str << endl;

	char str1[] = "aaccac\0";
	cout << str1 << " ==> ";
	stringFilter(str1);
	cout << str1 << endl;

	return 0;
}

运行结果：

acbac ==>
aaccac ==>

3. 不用除法求乘积：

  两个数组，A[]与B[]，其中B[]有如下的结果：
  B[i] = A[0]*A[1]*...*A[i-1]*A[i+1]*...*A[n-1];
  要求：
      求B[i]的过程中，不允许使用除法，也不允许使用额外的空间。

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void Multiply(int A[], int B[], int n)
{
    int i = 0;
    for( i = 0; i < n; i++)
    {
        B[i] = 1;
    }

    for( i = 1; i < n; i++)
    {
        B[i] = B[i-1]*A[i-1];
    }

    for( i = n-2; i >= 0; i--)
    {
        B[i] = B[i]*A[i+1];
        A[i] = A[i]*A[i+1];
    }
}

int main()
{
    int A[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int B[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
    int multi = 1;
    for(int i = 0; i < 10; i++)
    {
        multi *= A[i];
    }
    for(int i = 0; i < 10; i++)
    {
        cout << multi / A[i] << "\t";
    }

    Multiply(A, B, 10);

    for(int i = 0; i < 10; i++)
    {
        cout << B[i] << "\t";
    }

    return 0;
}

输出结果：

3628800 1814400 1209600 907200 725760 604800 518400 453600 403200 362880
3628800 1814400 1209600 907200 725760 604800 518400 453600 403200 362880

4. 汽车加油是否可以回到出发点转自：《待字闺中》

  城市的环形路由n个加油站，第i个加油站的油量用gas[i]来表示，有如下的一辆车：
  1. 它的油缸是无限量的，初始是空的。
  2. 它从第i个加油站到i+1个加油站的消耗油量为cost[i]
  现在你可以从任何加油站开始，路由加油站可以不断的加油，问是否能够走完环形路。如果可以返回开始加油站编号返回1，
否则返回-1.注意解决方案保证是唯一的。
  其中一个问题需要理解：在第i站时，油缸中有的油量可以支撑你到第i+1站，对于每一站都要如此。而并不是你的总油量大于
总的耗油量就可以的。
  暴力破解的方法：对每一个节点都试一下，然后找到每一站的油量都大于等于0的走法，返回开始的加油站。没有就返回-1。
时间复杂度为O(n^2)的时间复杂度。
  优化：
  上述的暴力破解方法中，我们可以看到有可以进行优化的地方。从第0个加油站开始，判断是否可以走完，然后从第1个加油站
开始判断，其实中间的计算已经做过了。反过来，我们用tank记录从0个站开始到某个站的油量。
  考虑从第0个站开始，到该加油站的油量为 gas[i]-cost[i]+tank;这样时间复杂度可以是O(n)，事实上确实如此：
  tank表示当前车的油缸里的油量。
  1. 从第0个站开始，tank+=gas[0]-cost[0]，只要tank>=0，我们就继续到下一个加油站
  2. 当不满足tank>=0时，顺着环路试着从下一个站开始，比如n-1: tank+=gas[n-1]-cost[n-1]。如果还小于0，继续实验再前一个
  3. 知道满足tank>=0，在进行第一步依次类推。
  4. 当一前一后这两个相遇了，算法也就结束了，tank>=0就成功，返回相遇的位置，否则失败，返回-1。
  上述方法的时间复杂度是 O(n)，作为一个整体来看，每一个阶段都直走了一次。

5. 连连看，判断两个图片之间是否可以连线（有条件）

  对于连连看，当点击两个图标时，判断两个图标是否可以通过一条最多具有两个拐点的线连接起来，首先看一个例子。
  如下图：

图中，两个绿色的A，我们可以通过两个途径测试是否两个A有满足条件的线存在。
  以横坐标为例，在图中我们以两个A所在的位置(3,3)和(7,7)所在的位置纵坐标向两边扩展，如果是空白格则并进来，否则停止。
由此可以得到A(3,3)的空白格为[0-13]，到A(7,7)的空白格为[0-15]，以其中一个A(3,3)为基准，将其空白格集合逐格向外扩展，并与A(7,7)的空白格集合进行对比，例如(7,3)(7,7)，分属两个集合的两个空白格之间有空白格通道，则说明找到了一条线。那么我们要得到的线就为 A(3,3) - (7,3) - A(7,7) ，中间经过了一个拐点(7,3)。
  如果对于横坐标上没有想通空白格通道时，可以以相同的方法测试一下在纵坐标上是否有这样的通道。
  对于出于边界的两个图片，如两个红色的D，我们可以通过箭头线所画路径连接消除。这里要做一个特殊的处理，就是在整个矩形周边留出一圈空白格，这样就可以很好地使用上述的方法进行解决。

6. 二叉树的sibling node：

有如下的结构体，其中的sibling字段指向本层节点的左边节点，如果没有则设置为NULL。

typedef struct _BiNode
{
    struct _BiNode * left;
    struct _BiNode * right;
    struct _BiNode * sibling;
    int value;
}BiNode;

例如：一个二叉树如下图所示，其对应的处理以后的如其下的图所示。

A
/ \
B C
/ \ \
D E G
/ / \
K J L

A
/ \
B <- C
/ \ \
D--E <- G
/ / \
K ---J <----- L

代码如下（未建立二叉树进行验证）

BiNode* ConnectSibling(BiNode * root)
{
    if(root == NULL || (root->left == NULL && root->right == NULL))
    {
        return root;
    }

    BiNode* p = NULL;
    vector<BiNode *> nodes;
    nodes.push_back(root);
    root->sibling = NULL;
    int start = 0, end = 1, cur = 0;
    while( start < end)
    {
        cur = start;
        while(cur+1 < end)
        {
            nodes[cur+1]->sibling = nodes[cur];
            cur ++;
        }

        cur = start;
        while( cur < end)
        {
            p = nodes[cur]->left;
            if( p != NULL)
            {
                nodes.push_back(p);
                p->sibling = NULL;
            }
            p = nodes[cur]->right;
            if( p != NULL)
            {
                nodes.push_back(p);
                p->sibling = NULL;
            }
            cur++;
        }
        start = end; end = nodes.size();
    }

    return root;
}

7. 蛇形矩阵
输出蛇形矩阵，蛇形矩阵如下矩阵所示，使用两种方法实现蛇形矩阵的输出，空间复杂度分别为O(n^2) 和 O(1)

1 2 6 7
3 5 8 13
4 9 12 14
10 11 15 16

#define Num 5
void SnakeArray(int N)
{
    int array[Num][Num];

    int i = 0, j = 0, index = 1, n = 0;
    for( int k = 0; k <= 2*(N-1); k++)
    {
        if( k > N-1)
        {
            n = k - (N-1);
        }

        if(k % 2 == 0)
        {
            i = k - n; j = k-i;
            while( i >= n)
            {
                array[i][j] = index++;
                i--; j++;
            }
        }
        else if(k % 2 == 1)
        {
            j = k-n; i = k-j;
            while( j >= n)
            {
                array[i][j] = index++;
                j--; i++;
            }
        }
    }

    for(int i = 0; i < N; i++)
    {
        for(int j = 0; j < N; j++)
        {
            cout << array[i][j] << " ";
        }
        cout << endl;
    }

    return ;
}

8. N个有序单链表合并
有N个有序的单链表，将这N个有序的单链表合并为一个有序的单链表。

typedef struct _Node
{
    struct _Node * next;
    int value;
}Node;

Node * MergeLists(int N, Node* lists[])
{
    if(N<=0 || lists == NULL)
        return NULL;

    if( N == 1)
    {
        return lists[0];
    }

    int k = 1;
    Node * p = lists[0], *q = NULL, *r = NULL, *cur = NULL;
    while( k < N)
    {
        q = p;
        r = lists[k];
        if( q->value < r->value)
        {
            p = cur = q;
            q = q->next;
        }
        else
        {
            p = cur = r;
            r = r->next;
        }

        while( q != NULL && p != NULL)
        {
            if( q->value < r->value)
            {
                cur->next = q;
                cur = q;
                q = q->next;
            }
            else
            {
                cur->next = r;
                cur = r;
                r = r->next;
            }
        }
        if( q != NULL)
        {
            cur->next = q;
        }
        else if( r != NULL)
        {
            cur->next = r;
        }

        k++;
    }

    return p;
}

By Andy @ 2013年10月18日