面试算法题-01

最新推荐文章于 2024-10-30 16:47:45 发布
最新推荐文章于 2024-10-30 16:47:45 发布
阅读量518 收藏 1
点赞数
分类专栏： 面试算法题 文章标签： 算法 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/deepquiet/article/details/71023339
版权

1.在一个数组中找出有几个k,用O(log(n))算法实现
代码:

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<string>
using namespace std;
int arr[10]={2,3,3,3,3,4,5};
int first(int k) {
    int left=0, right=7;
    while(left<=right) {
        int mid = (left+right)>>1;
        if(arr[mid]>k) right=mid-1;
        else if(arr[mid]<k) left=mid+1;
        else {
            if(arr[mid-1]==k && mid>0) {
                right = mid-1;
            }
            else return mid;
        }
    }
    return -1;
}
int last(int k) {
    int left=0, right=7;
    while(left<=right) {
        int mid = (left+right)>>1;
        if(arr[mid]>k) right=mid-1;
        else if(arr[mid]<k) left=mid+1;
        else {
            if(arr[mid-1]==k && mid<right-1) {
                left = mid+1;
            }
            else return mid;
        }
    }
    return -1;
}
int main() {
    int f = first(3);
    int l = last(3);
    if(f!=-1 && l!=-1) {
        printf("%d\n", l-f+1);
    }
    else printf("can not found\n");
    return 0;
}

2.判断平衡二叉树

struct BinaryTreeNode {
    int m_valuel;
    BinaryTreeNode *m_lson;
    BinaryTreeNode *m_rson;
};

//复杂度大于O(n),小于O(n^2)

int GetDepth(BinaryTreeNode *root) {
    if(root == NULL) {
        return 0;
    }
    int l = GetDepth(root->m_lson);
    int r = GetDepth(root->m_rson);
    return l>r?l+1:r+1;
}

bool IsBalanced(BinaryTreeNode *root) {
    if(root == NULL) return true;
    int l = GetDepth(root->m_lson);
    int r = GetDepth(root->m_rson);
    int dis = r-l;
    if(dis>=-1 && dis<=1) {
        return IsBalanced(root->m_lson)&&IsBalanced(root->m_rson);
    }
    else return false;

}
//后序遍历,复杂度O(n)
bool IsBalanced(BanaryTreeNode *root, int *depth) {
    if(root == NULL) {
        *depth=0;
        return true;
    }
    int l=0;
    int r=0;
    if(IsBalanced(root->m_lson,&l) && IsBalanced(root->m_rson,&r)) {
        int dis=l-r;
        if(dis>=-1 && dis<=1) {
            *depth=1+l>r?l:r;
            return true;
        }
        else return false;
    }else return false;
}

3.输入一个数组,其中有两个值是惟一的,其他都有两个,求这两个值,要求空间复杂度是O(1),时间复杂度O(n)
看了解答,觉得神他妈复杂,自己写了一个,试了几个例子,是对的

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
using namespace std;
int arr[8] = {2,4,3,5,3,2,5,6};
int main() {
    sort(arr,arr+8);
    int flag=0;
    for(int i=0; i<7;) {
        if(arr[i]!=arr[i+1]) {
            printf("%d\n",arr[i]);
            i++;
            flag++;
        }
        else {
            i+=2;
        }
    }
    if(flag != 2) printf("%d\n",arr[7]);
}

这里补一下答案的代码:

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
using namespace std;
int arr[10]={2,4,4,6,3,2,5,5};
void FindNumAppearOnce(int n) {
    if(arr==NULL || n<2) return;
    int sum=0;
    for(int i=0; i<n; i++) {
        sum ^= arr[i];
    }
    int pos = 0;
    while((sum&1)!=1 && (pos<32)) {
        pos++;
        sum >>= 1;//右移
    }
    if(pos>=32) {
        return;
    }
    int one=0, two=0;
    int num=1<<pos;
    for(int i=0; i<n; i++) {
        if((arr[i]&num)!=0) {
            one ^= arr[i];
        }
        else {
            two ^= arr[i];
        }
    }
    printf("%d %d\n", one, two);

}

int main() {
    FindNumAppearOnce(8);
    return 0;

}

在一个数组里找两个数,这两个数的和是特定的值,要求时间为O(n),数组有序
代码:

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
using namespace std;
int arr[6] = {1,2,4,7,11,15};
int n = 6;
bool Find(int s, int& num1, int& num2) {
    bool isFind = false;
    if(arr==NULL || n<=0) {
        return isFind;
    }
    int p1=0, p2=n-1;
    while(p1<p2) {
        int sum=arr[p1]+arr[p2];
        if(sum == s) {
            isFind=true;
            num1=arr[p1],num2=arr[p2];
            break;
        }
        else if(sum > s) {
            p2--;
        }else p1++;
    }
    return isFind;
}
int main() {
    int a, b;
    if(Find(15,a,b)) printf("%d %d\n", a, b);
    else printf("not found\n");

    return 0;
}

给一个数n,从1-n中找出连续的串使得和为n,时间为O(n)
代码:

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<string>
using namespace std;
void print(int f, int t) {
    printf("%d", f);
    for(int i=f+1; i<=t; i++) printf(" %d", i);
    printf("\n");
}
void FindSequenceSum(int s) {
    if(s<3) return;
    int start=1,end=2,sum=3;
    int mid=(s+1)>>1;
    while(start<mid) {//超过一半接下来加的就是比一半大的数了,不可能得到s
        if(s == sum) {
            print(start,end);
            end++;
            sum += end;
        }else if(sum>s) {
            sum -= start;
            start++;
        }else {
            end++;
            sum += end;
        }

    }
}
int main() {
    FindSequenceSum(9);

    return 0;
}

题目：输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。句子中单词以空格符隔开。为简单起见，标点符号和普通字母一样处理。例如输入“I am a student.”，则输出“student. a am I”。
代码:空间复杂度高

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
using namespace std;
char str[105][100];
int main() {
    char s[105];
    memset(str, 0, sizeof(str));
    while(gets(s)) {
        int j = 0;
        for(int i=0; i<strlen(s);) {
            if(s[i]!=' ' && s[i] != '\n' && s[i] != '\0') {
                int z = 0;
                while(s[i]!=' ' && s[i] != '\n' && s[i] != '\0') {
                    str[j][z] = s[i];
                    z++, i++;
                }
                str[j][z] = '\0';
                j++;

            }else{
                i++;
            }
        }
        printf("%s", str[j-1]);
        for(int i=j-2; i>=0; i--) printf(" %s", str[i]);
        printf("\n");

    }

    return 0;
}

空间复杂度低:

#include <iostream>
#include<string>
#include<cstdio>
#include<cstring>

using namespace std;

void myReverse(char*, char*);
char * senReverse(char*);
int main()
{
    char sen[]="hello, I am a student!";
    char *result=senReverse(sen);
    cout << result << endl;
    return 0;
}
void myReverse(char *start, char* end) {
    char temp;
    while(start<end) {
        temp = *start;
        *start = *end;
        *end = temp;
        start++;
        end--;
    }

}

char * senReverse(char* sen) {
    char *start = sen, *end = sen+strlen(sen)-1;
    myReverse(start, end);
    end=start;
    while(*start != '\0') {
        if(*end==' '||*end=='\0') {
            myReverse(start,--end);
            if(*end=='\0') break;
            end+=2;
            start = end;

        }else ++end;
    }
    return sen;
}

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如输入字符串”abcdefg”和数字2，该函数将返回左旋转2位得到的结果”cdefgab”。
代码:

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
void ReverseWord(char* begin, char*end) {
    char temp;
    if(begin==NULL || end==NULL) {
        return;
    }
    while(begin<end) {
        temp = *begin;
        *begin = *end;
        *end = temp;
        begin++, end--;
    }
}
char* LeftRotateString(char* string, int k) {
    if(string==NULL || k<=0) return string;
    int len = (int)strlen(string);
    char* begin = string;
    char *end = string+len-1;
    if(k>len) return NULL;
    ReverseWord(begin, begin+k-1);
    ReverseWord(begin+k, end);
    ReverseWord(begin,end);
    return string;

}
int main() {
    char str[] = "abcdefg";
    char *string = NULL;
    string = LeftRotateString(str,2);
    cout<<string<<endl;
    return 0;
}

约瑟夫环路:
n个数从1-n形成一个环,每次删除环中的第m个数,求最后一个被删除的数
代码:

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<iostream>
using namespace std;
struct ListNode {
    int value;
    ListNode *nextNode;
};
void BuildList(ListNode **headNode, int *arrNum, int n) {
    if(arrNum == NULL || n<=0) return;
    (*headNode)->value = arrNum[0];
    (*headNode)->nextNode=NULL;
    ListNode *pre = (*headNode);
    for(int i=1; i<n; i++) {
        ListNode *newNode = new ListNode();
        newNode->value = arrNum[i];
        newNode->nextNode = NULL;
        pre->nextNode = newNode;
        pre = newNode;
    }
    pre->nextNode = *headNode;
}
int GetLastNum(ListNode *headNode, int n, int m) {
    /*if(headNode==NULL || n<=0 || m<=0) {
        throw exception("error");
    }*/
    int count=n;
    ListNode *pNode = headNode;
    while(count>1) {
        int pos = 1;
        while(pos<m-1) {
            ++pos;
            pNode=pNode->nextNode;
        }
        ListNode *tmpNode = pNode->nextNode;
        pNode->nextNode = tmpNode->nextNode;
        delete tmpNode;
        tmpNode = NULL;
        --count;
        pNode=pNode->nextNode;
    }
    return pNode->value;
}
void print(ListNode* headNode) {
    ListNode *pNode = headNode;
    cout<<pNode->value<<endl;
    pNode=pNode->nextNode;
    while(pNode!=headNode) {
        cout<<pNode->value<<endl;
        pNode=pNode->nextNode;
    }
}
int main() {
    int arrNum[] = {1,2,3,4,5};
    ListNode *headNode = new ListNode();
    BuildList(&headNode,arrNum,5);
//  print(headNode);
    int ans = GetLastNum(headNode, 5, 3);
    printf("%d\n", ans);
    return 0;
}

用位运算求两数相加:

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
using namespace std;
int GetSum(int num1, int num2) {
    while(num2 != 0) {
        int sum = num1^num2;
        int carry = (num1&num2)<<1;
        num1=sum;
        num2=carry;
    }
    return num1;
}
int GetSum2(int num1, int num2) {
    if(num2==0) return num1;
    int sum = num1^num2;
    num2 = (num2&num1)<<1;
    num1 = sum;
    GetSum(num1, num2);
}

int main() {
    int ans = GetSum2(5,6);
    printf("%d\n", ans);

    return 0;
}
deepquiet
关注
专栏目录
北大MOOC - 程序设计与算法（三）第三周测验
weixin_42503072的博客
03-17 2070
1:返回什么才好呢 程序填空，使其按要求输出 #include <iostream> using namespace std; class A { public: int val; A(int // 在此处补充你的代码 }; int main() { int m,n; A a; cout << a.val << endl; while(cin &...
算法工程师面试题--概率题
ciecus_csdn的博客
09-08 1816
常考题目 文章目录1- 圆内随机抽样问题：方法：相关问题：能够通过半径和角度的形式实现？2- 组成三角形的概率问题：回答：3- 吃苹果问题：回答4- 扔骰子的期望问题回答5- 球涂白的次数期望题目回答6- 宝剑升级次数的期望问题回答 1- 圆内随机抽样 问题： 如何实现在半径为1的圆内均匀随机抽样 方法： 方法： 在 x∈[−1,1],y∈[−1,1]x\in [-1,1], y\in [-1,1]x∈[−1,1],y∈[−1,1]随机选取，如果此点在圆内，就是所求的点。 相关问题：能够通过半径和角度的
2019第十届蓝桥杯C/C++ 省赛A组 题解
蒟蒻本蒻的博客
03-11 788
A 2658417854 注意用long long #include<iostream> using namespace std; bool check(int a) { for(;a;a=a/10) { int b=a%10; if(b==2||b==0||b==1||b==9) return true; } return false; } int main() { long long int ans; for(int i=1;i<=2019;i++)
c++基础
qq_46107892的博客
09-12 2903
c++基础学习
leetcode二叉树面试题目集锦
xiangxianghehe的博客
08-18 6970
struct BinaryTreeNode { int value; BinaryTreeNode* left; BinaryTreeNode* right; BinaryTreeNode(int x) : value(x), left(NULL), right(NULL) {} }; 初始化 BinaryTreeNode *root = new ...
二叉树的各种创建方法
lingling_nice的博客
07-08 7万+
1.前序创建#include&lt;stdio.h&gt; #include&lt;string.h&gt; #include&lt;stdlib.h&gt; #include&lt;malloc.h&gt; #include&lt;iostream&gt; #include&lt;stack&gt; #include&lt;queue&gt; using namespace std; typed
算法面试题汇总
学Java，找哪吒
08-23 1万+
大家好，我是哪吒，一个热爱编码的Java工程师，本着“欲速则不达，欲达则欲速”的学习态度，在程序猿这条不归路上不断成长，所谓成长，不过是用时间慢慢擦亮你的眼睛，少时看重的，年长后却视若鸿毛，少时看轻的，年长后却视若泰山，成长之路，亦是渐渐放下执念，内心归于平静的旅程。 也许，我们永远都不会知道自己能走到何方，遇见何人，最后会变成什么样的人，但一定要记住，能让自己登高的，永远不是别人的肩膀，而是挑灯夜战的自己，人生的道路刚刚启程，当你累了倦了也不要迷茫，回头看一看，你早已不再是那个年少轻狂的少年。 .
字节跳动面试算法题
GarfieldEr007的专栏
02-09 2462
1. 实现一个字符串转换整数的函数； 2. 输入两个递增排序的链表，合并这两个链表并使新链表中的结点仍然是按照递增排序的，例如： 链表1：1 -> 3 -> 5 -> 7 链表2: 2 -> 4 -> 6 -> 8 合并后的链表3: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 链表定义： struct ListNode { int m_nValuel ListNode*...
前端面试算法题
cxuyuanLch的博客
03-19 4794
1. 数组扁平化 . 数组是 JS 中使用频率仅次于对象的数据结构，官方提供了众多的 API。 今天我们来谈谈如何扁平化（flatten）数组。 扁平化就是将嵌套的数组变成一维数组的过程。 通常有几种方法可以实现扁平化： 第一个就是迭代递归法 var array = [[1,2,3],4,5,6,[[7]],[]] var result = flatten(array) console.log(result) for…of 实现 function flatten(arr, result = []) {
Java后端真实面试题大全(有详细答案)--高频/真题
热门推荐
IT利刃出鞘的博客
11-24 14万+
本文分享Java后端真实高频面试题，有详细答案，保你稳过面试。题目包括：Java基础、多线程、JVM、数据库、Redis、Shiro、Spring、SpringBoot、MyBatis、MQ、ELK、SpringCloud、设计模式等。 本博客包含从简单到困难、从高频到低频的题目，适合所有Java求职者，包括：刚入门的、三年以内经验、三到五年经验、五到十年经验等。
leetcode面试算法题-Leetcode-in-python-50-Algorithms-Coding-Interview-Questio
07-07
《LeetCode面试算法题——Python实现的50道编程面试问题》 在IT行业中，面试是检验求职者技能的关键环节，而算法与数据结构无疑是衡量程序员能力的重要标准。LeetCode作为一个知名的在线平台，提供了大量的算法题目...
基于Python的华为OD算法面试题-Huawei-OD-Python-master
05-24
在推荐资料部分，给出了学习Python和算法的优秀资料，如果大家觉得解题有困难，可以按照顺序学习这些资料，再来练习算法题。 可以先完成精选100分题，再练习200分题，最后可以挑选其他100分题练习，建议每天练习3道...
算法大全-面试题-数据结构.pdf.zip_算法
09-23
《算法大全-面试题-数据结构.pdf》是一个深入探讨算法和数据结构的资源，对于程序员，尤其是准备面试的开发者来说，这是一个极其宝贵的学习材料。它涵盖了算法和数据结构的基础概念，以及在实际问题中的应用，旨在...
算法大全-面试题-数据结构
11-16
在面试中，数据结构和算法的考察占据着重要地位，因为它们是软件开发和计算机科学中不可或缺的基础。 单链表是一种常见的线性数据结构，它由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。在面试中...
面试高频算法题总结-剑指Offer题解
09-01
面试高频算法题总结-剑指Offer题解，主要包含： 数据结构 数组 字符串 链表 栈和队列 二叉树 图 堆 线段树 字典树 单调栈 算法 二分查找 排序 递归 动态规划 分治 记忆化搜索 贪心 回溯 位运算 数学 设计 其他 共66...
数对的最大曼哈顿距离[ABC178E] Dist Max
最新发布
2301_80882026的博客
10-30 500
/曼哈顿距离化简绝对值之后最终可以化简为两种取最大的即可PII p[N];cin >> n;i <= n;
代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数
Zuoriqiufeng的博客
10-30 405
【代码】代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数。
xtu oj 连接字符串
Go offline for a while
10-30 968
最后总结一下：这题思路比较直观，找公共的元素，代码细节比较多，一个是要求输出字典序小的，第二是前面字符串要枚举完最后一个元素才算满足条件，第三是两个字符串可能完全没有公共部分，需要特判。
【力扣打卡系列】二分查找(搜索旋转排序数组)
qq_45734745的博客
10-29 307
坚持按题型打卡&刷&梳理力扣算法题系列，语言为go，Day11。
微软数据结构与算法面试题41-60答案解析
"微软等数据结构+算法面试100题[第41-60题答案]" 在软件开发领域，尤其是面试过程中，数据结构和算法是衡量候选人技术能力的重要标准。微软等顶级科技公司在面试时，常常会设计一系列涵盖各种数据结构和算法的问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值