小编let*_*tsc的帖子

这是一个面试问题.直到现在,我曾经认为这些问题纯粹依赖于编译器,不应该担心我,但现在,我对它很好奇.

假设您有两种结构:

struct A {  
  int* a;  
  char b;  
 }  

而且,

struct B {  
  char a;  
  int* b;  
}  

那么你更喜欢哪一个？为什么？我的回答是这样的(虽然我有点在黑暗中拍摄)第一个结构应该是首选的,因为编译器为字大小的一些倍数(这是指针的大小 - 在32上的4个字节)分配结构的空间位机和64位的8字节).因此,对于这两种结构,编译器将分配8个字节(假设它是32位机器).但是,在第一种情况下,填充将在所有变量之后(即在a和b之后)完成.因此,即使有一些机会,b得到一些溢出的值并破坏我的下一个填充字节,但我的a仍然是安全的.

他似乎并不高兴,并要求第一个结构在第二个结构上的一个缺点.我没有太多话要说.:d

请帮我解答.

#include <stdio.h>

typedef struct node
{
      int i;
      struct node *next;
}node;

node getnode(int a)
{
      struct node n;
      n.i=a;
      n.next=NULL;
      return n;
}

main()
{
     int i;
     node newtemp,root,temp;

     scanf("%d",&i);
     root=getnode(i);
     temp=root;

     while(i--)
     {
         newtemp=getnode(i);

         temp.next=&newtemp;
         if(root.next==NULL)
         {
            root=temp;
         }
        temp=*(temp.next);
     }


     temp=root;

     while( temp.next != NULL )
     {
         printf(" %d ",temp.i);
         temp=*(temp.next);
     }
}

我试图在不使用malloc的情况下创建链表.编程只打印根,后面没有节点.我找不到这个bug.如果有任何内存问题,gcc编译器会抛出一个分段错误.(？)请忽略糟糕的编程风格..

我正在阅读用于查找最小生成树的算法(在加权图的情况下)以及查找图是否具有哈密顿路径(这取决于哈密顿循环的存在).我把一切搞砸了.那哈密顿路径和生成树之间的区别是什么？两者都覆盖图中的所有顶点.虽然我们可以使用有效的算法来查找生成树(可能是最小的生成树),但为什么我们不能找到哈密顿电路的算法？我们可以继续一次添加和删除一个边缘,直到我们达到一个周期,也许,我们可以找到一个哈密顿周期？

当我在完成任务时,我发现我们不应该使用如下任务:

 char *s="HELLO WORLD";

使用这种语法的程序容易崩溃.

我尝试过并使用过:

 int fun(char *temp)
 {
    // do sum operation on temp
    // print temp.
  }
  fun("HELLO WORLD");

甚至上面的工作(虽然输出是编译器和标准特定的).

相反,我们应该尝试strdup()或使用const char*

我曾尝试在博客上阅读其他类似的问题,但无法得到上述代码为什么工作的概念.

内存分配？const有什么不同？

假设你有一个大小为n的数组A [1..n],它包含集合{1..n}中的元素.但是,缺少两个元素(并且可能重复了两个数组元素).找到缺少的元素.

例如,如果n = 5,A可以是A [5] = {1,2,1,3,2}; 所以缺少的元素是{4,5}

我使用的方法是:

int flag[n] = {0};  
int i;  
for(i = 0; i < n; i++)  {  
  flag[A[i]-1] = 1;  
 }  

for(i = 0; i < n; i++)  {  
 if(!flag[i]) {  
    printf("missing: %d", (i+1));  
}  

空间复杂性来自O(n).我觉得这是一个非常儿童和低效的代码.那么请你提供一个更好的空间和时间复杂度的更好的算法.

我正在尝试从API中获取数据.API已启用CORS支持并返回以下对OPTIONS请求的响应:

Access-Control-Request-Headers:content-type  
Access-Control-Allow-Origin:*  

API不允许'Content-type'任何其他内容'application/json'.

使用此限制,我试图使用fetchReact-Native方法来获取数据.

方法1(无人):

{
    method: 'POST',
    mode: "no-cors",
    headers: {
       'content-type': 'application/json'
}

使用此方法,浏览器会自动将内容类型发送为"text/plain".我假设这是因为CORS默认只允许三个标头中的一个.但是,由于服务器不支持此内容类型,因此会针对不支持的内容类型返回错误.

方法2(与cors或没有任何东西):

{ 
    method: 'POST',
    mode: "cors", // or without this line
    redirect: 'follow',
    headers: {
        'content-type': 'application/json'
    }
}   
...   
.then(response => console.log(response))

在这种情况下,使用Chrome的F12网络工具,我可以看到服务器返回数据:对服务器的第一个请求是fetchfor OPTIONS.为此,服务器回复一个空对象以及上面的标题集.下一个调用是实际的POST API调用,服务器使用包含一些数据的正确JSON响应向其响应.但是,通过我的代码进入控制台的响应是{}.我假设这是因为react的fetchAPI返回了OPTIONS调用的响应而不是实际的POST调用.

有没有办法忽略OPTIONS请求的响应并获得then处理后续请求响应的方法？

这是一个面试问题(再次).

给定一个单独连接的链表,找到列表中最大的回文.(你可以假设回文的长度是均匀的)

我做的第一种方法是使用堆栈 - 我们从头开始遍历列表并继续推送字母.每当我们发现在堆栈的顶部的字母是一样的链表上的下一个字母,开始弹出(与增加链表指针),并设置上的匹配字母数的计数.找到不匹配后,推回从堆栈中弹出的所有字母,然后继续推送和弹出操作.这种方法的最坏情况复杂性是O(n2),例如当链表只是一个相同字母的字符串时.

为了改善空间和时间的复杂性(通过一些常数因素),我提出将链表复制到一个数组并找到数组中最大尺寸的回文,这再次需要O(n2)时间复杂度和O(n)空间复杂度.

有没有更好的方法来帮助我？:(

这是一个面试问题.

给定一个字符串,如:123456abcdef,由n/2个整数后跟n/2个字符组成.将字符串重新排序为包含为1a2b3c4d5e6f.算法应该是就地的.

我给出的解决方案是微不足道的 - O(n ^ 2).只需将字符向左移动n/2个位置即可.

我尝试使用递归作为 -
a.将上半场的后半部分换成第二部分的前半部分 - 例如
123 456 abc def
123 abc 456 def
b.递归两半.

我被困的pbm是交换随元素的数量而变化 - 例如.

接下来做什么？123 abc 12ab 3c

该怎么做:12345 abcde 123abc 45ab

这是一个非常古老的问题,可能是重复的.请告诉我.. :)

另一个例子:输入:38726zfgsa输出:3z8f7g2s6a

我有两个二叉搜索树.例如,A和B.接下来,我被要求从树A中删除树B.

通过删除,我的意思是从A中删除B中存在的所有节点.注意:B不一定是A的子树.

例如:
A:

      50   
     / \  
    10  75  
   /   / \  
  1   60   90                 

Run Code Online (Sandbox Code Playgroud)

B:

     10
     / \
    1   75

Run Code Online (Sandbox Code Playgroud)

结果树应该是:

     50
       \
        60
         \ 
          90

Run Code Online (Sandbox Code Playgroud)

我想到了两种方法:
A1:
node*deleteTree(node*A,node*B);
取树B的根.从树A中删除此节点(通过正常的BSt删除方法).接下来将问题分为两部分 - B的左子树和B的右子树.对于每个子树,递归.对于左子树,占用已删除节点的节点应作为树A的根.对于右子树,已删除节点的inorder后继应作为树A的根服务器.

A2:另一种方法有点奇怪.我找到了树A的inorder和preorder遍历.使用二进制搜索和递归查找并删除树B中的所有节点(我们不修改预订).最后从inorder(剩余)和预订(未更改)重新构建我们的bst.

问题A:找到一种有效的BST方式.
问题B:为任何二叉树(不仅仅是BST)找到一种有效的方法.

我有一个接受用户输入的功能.输入可以是整数,浮点数或字符串.我有三个重载函数,应根据输入数据的DATA TYPE调用.例如,如果用户输入整数(例如100),则应调用具有整数参数的函数.如果用户输入字符串(例如"100"),则应调用具有字符串参数的函数.

所以我需要找出输入数据的数据类型.使用正则表达式,我能够区分整数和浮点数(因为我只需要找出类型,我不喜欢使用cpan.org提供的库),但我无法弄清楚如何区分字符串中的整数.Perl对待"100"和100对待？有没有办法解决这个问题？