C++经典面试题（基础算法版）

最新推荐文章于 2024-03-31 20:21:58 发布
最新推荐文章于 2024-03-31 20:21:58 发布
阅读量767 收藏 12
点赞数
分类专栏： 【------C++------】 数据结构 算法 文章标签： C++面试题 简单算法版
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Aidam_Bo/article/details/86715865
版权

#添加头文件

#include <assert.h>
#include <string.h>
#include <stack>


 1.实现strcpy.  

char* MyStrCpy( char *pDest, const char *pSrc )  
{  
    if( nullptr == pDest || nullptr == pSrc )  
    {  
        return nullptr;  
    }  
    if( pDest == pSrc )  
    {  
        return pDest;  
    }  
    char *pIter = pDest;  
    while( ( *pIter++=*pSrc++ ) !='\0' );  
    return pDest;  
}  


 
2.实现strcat.  
 

char* MyStrCat( char *pDest, const char *pSrc )  
{  
    if( nullptr == pDest || nullptr == pSrc )  
    {  
        return nullptr;  
    }  
 
    char *pIter = pDest + strlen( pDest );  
    while( ( *pIter++=*pSrc++ ) != '\0' );  
    return pDest;  
}  


 
3.实现CString字符串类缺省四个方法  

class MyCString  
{  
public:  
 
    MyCString( char *pData = nullptr )  
    {  
        if( nullptr == pData )  
        {  
            mpData = new char[ 1 ];  
            assert( nullptr != mpData );  
            *mpData = '\0';  
        }  
        else  
        {  
            mpData = new char[ strlen( pData ) + 1 ];  
            assert( nullptr != mpData );  
            strcpy( mpData, pData );  
        }  
    }  
 
    MyCString( const MyCString &Other )  
    {  
        mpData = new char[ strlen( Other.mpData ) + 1 ];  
        assert( nullptr != mpData );  
        strcpy( mpData, Other.mpData );  
    }  
 
    ~MyCString()  
    {  
        if( nullptr != mpData )  
        {  
            delete [] mpData;  
            mpData = nullptr;  
        }  
    }  
 
    const MyCString& operator =( const MyCString &Other )  
    {  
        if( this == &Other )  
        {  
            return *this;  
        }  
        delete [] mpData;  
        mpData = new char[ strlen( Other.mpData ) + 1 ];  
        assert( nullptr != mpData );  
        strcpy( mpData, Other.mpData );  
        return *this;  
    }  
 
private:  
 
    char *mpData;  
};  


 
4.不使用第三个变量交换两个数的值  

void SwapA( int &A, int &B )  
{  
    if( A == B )  
    {  
        return;  
    }  
    A = A + B;  
    B = A - B;  
    A = A - B;  
}  
void SwapB( unsigned int &A, unsigned int &B )  
{  
    if( A == B )  
    {  
        return;  
    }
    A = A ^ B;  
    B = A ^ B;  
    A = A ^ B;  
}  


 
5.C语言中字符串转数字的方法是什么( atoi )，请实现它  

int Myatoi( const char *pString )  
{  
    assert( nullptr != pString );  
    const int Len = strlen( pString );  
    int Value = 0;  
    int Times = 1;  
    for( int i = Len -1; i >= 0; --i, Times *= 10 )  
    {  
        Value += ( pString[ i ] - '0' ) * Times;  
    }  
    return Value;  
}  


 
6.实现一个将字符串逆序的方法  
 

char* MyInverted( char *pDest )  
{  
    assert( nullptr != pDest );  
    const int Len = strlen( pDest );  
    char T = 0;  
    for( int i = 0; i < Len / 2; ++i )  
    {  
        T = pDest[ i ];  
        pDest[ i ] = pDest[ Len - i - 1 ];  
        pDest[ Len - i -1 ] = T;  
    }  
    return pDest;  
}  


 
7.实现一个将字符串中所有字母转换为大写的方法  

char* MyUpper( char *pDest )  
{  
    assert( nullptr != pDest );  
    for( char *i = pDest; *i != '\0'; ++i )  
    {  
        if( *i < 'a' || *i > 'z' )  
        {  
            continue;  
        }  
        *i -= 'a' - 'A';  
    }  
    return pDest;  
}  


 
8.已知一个数组已经降序排序请用二分查字法找到其中的某个元素找到返回索引否则返回-1  
 

int BinarySearch( int *pArray, int Count, int Value )  
{  
    assert( nullptr != pArray );  
    int Left = 0;  
    int Right = Count -1;  
    int Mid = 0;  
    while( Left <= Right )  
    {  
        Mid = ( Left + Right ) / 2;  
        if( Value < pArray[ Mid ] )  
        {  
            Right = Mid - 1;  
        }  
        else if( Value > pArray[ Mid ] )  
        {  
            Left = Mid + 1;  
        }  
        else  
        {  
            return Mid;  
        }  
    }  
    return -1;  
}  
 
struct Node  
{  
    Node *mpNext;  
    int mData;  
};


9.删除链表中值为Value的所有元素( [Head]->[node1]->[node2]->...[noden] )
 

void DeleteFromList( Node *pHead, int Value )
{
    Node *pPrev = pHead;
    Node *pNext = pHead->mpNext;
    while( nullptr != pNext )
    {
        if( pNext->mData != Value )
        {
            pPrev = pNext;
            pNext = pNext->mpNext;
        }
        else
        {
            pPrev->mpNext = pNext->mpNext;
            delete pNext;
            pNext = pPrev->mpNext;
        }
    }
}  


 
10.在链表Index位置插入新的值为Value的元素  
 

void InsertFromList( Node *pHead, int Index, int Value )  
{
    Node *pIter = pHead;
    for( int i = 0; i < Index && nullptr != pIter; ++i, pIter = pIter->mpNext );
    assert( nullptr != pIter );
    Node *pNew = new Node;
    pNew->mData = Value;
    pNew->mpNext = pIter->mpNext;
    pIter->mpNext = pNew;
}  


 
11.将链表逆序  
 

Node* InvertedFromList( Node *pHead )  
{  
    //A->B->C
    Node *pPrev = pHead;            //A
    Node *pNext = pHead->mpNext;        //B
    Node *pNextNext = nullptr;        //C
    while( nullptr != pNext )  
    {
        pNextNext = pNext->mpNext;    //C = B->C
        pNext->mpNext = pPrev;        //B->A
 
        pPrev = pNext;                //A = B
        pNext = pNextNext;            //B = C
    }
    pHead->mpNext = nullptr;//C->B->A->null
    return pPrev;            //return C( new head )
}  
 


12.判断X年X月X日是这年的第几天  

int GetDay( int Year, int Month, int Day )
{  
    int MonthDays[ 13 ] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };  
 
    if( ( Year % 4 == 0 && Year % 100 != 0 ) || ( Year % 400 == 0 ) )  
    {  
        ++MonthDays[ 2 ];  
    }  
 
    int Days = 0;  
    for( int i = 1; i < Month; ++i )  
    {  
        Days += MonthDays[ i ];  
    }  
    Days += Day;  
 
    return Days;  
}


13.求斐波拉契数列第N项
 

int GetFibonacci1( int N )
{
    if( 1 == N || 2 == N )
    {
        return 1;
    }
    if( 3 == N )
    {
        return 2;
    }
    int A = 2;
    int B = 3;
    int C = 5;
    for( int i = 0; i < N - 4; ++i )
    {
        C = A + B;
        A = B;
        B = C;
    }
    return C;
}


 
14.递归求斐波拉契数列数列第N项
 

int GetFibonacci2( int N )
{
    if( 1 == N || 2 == N )
    {
        return 1;
    }
    return GetFibonacci2( N - 1 ) + GetFibonacci2( N - 2 );
}


15.实现一个产生[N-M]区间数字的随机方法
 

int GetRandomRange( int N, int M )
{
    if( N == M )
    {
        return N;
    }
    if( N > M )
    {
        N = N + M;
        M = N - M;
        N = N - M;
    }
    return N + ( rand() % ( M - N + 1 ) );
}
 


16.实现一个产生[0~1]之间的随机浮点数
 

double GetRandomRange()
{
    return rand() / static_cast< double >( RAND_MAX );
}


17.实现一个打印出1-1000之间的所有素数的方法
 

void PrintfPrime()
{
    //1不是素数
    //2是最小非奇数素数
    //直接从3开始
    printf( "2\n" );
    bool b = false;
    for( int i = 3; i <= 1000; ++i )
    {
        b = true;
        for( int j = 2; j <= i / 2; ++j )
        {
            if( i % j == 0 )
            {
                b = false;
                break;
            }
        }
        if( b )
        {
            printf( "%d\n", i );
        }
    }
}


 
18.已知Z = X + Y 其中 Z, X, Y 均为无符号int型 定义一个宏判断Z是否已经越界
 

#define IS_OVER_FLOW( Z, X, Y ) ( Z < ( ( X ) < ( Y ) ? ( Y ) : ( X ) ) )


 
19.请用栈实现队列
 

int QueuePop( std::stack< int > &StackA )
{
    std::stack< int > StackB;
    while( false == StackA.empty() )
    {
        StackB.push( StackA.top() );
        StackA.pop();
    }
 
    const int top = StackB.top();
    StackB.pop();
 
    while( false == StackB.empty() )
    {
        StackA.push( StackB.top() );
        StackB.pop();
    }
    return top;
}


 
20.已知X班X成绩0-100分编写一个方法实现0-59打印不合格,60-69打印合格,70-79打印良好,80-100打印优秀，不能使用if,:?,switch
 

void PrintScore( int Score )
{
    assert( Score >= 0 && Score <= 100 );
    const char *pString[] =
    { 
        "不合格",
        "不合格",
        "不合格",
        "不合格",
        "不合格",
        "不合格",
        "合格",
        "良好",
        "优秀",
        "优秀",
        "优秀",
    };
    printf( "%s\n", pString[ Score / 10 ] );
}


21.实现strncpy
 

char *Mystrncpy( char *pDest, const char *pSrc, int Count )
{
    assert( NULL != pDest && NULL != pSrc );
    if( pDest == pSrc )
    {
        return pDest;
    }
    if( Count <= 0 )
    {
        return pDest;
    }
    char *pStart = pDest;
    while( ( Count-- ) > 0 && ( *pStart++=*pSrc++ ) );
    *pStart = '\0';
    return pDest;
} 


22.C语言中数字转字符串的方法是什么？(itoa)请实现他
 

char* Myitoa( char *pDest, int val, int radix )
{
    assert( NULL != pDest );
    assert( radix > 1 );
    const bool IsMinu = val < 0;
    char buffer[ 16 ] = {};
    int count = 0;
 
    do
    {
        buffer[ count++ ] = abs(val) % radix;
        val /= radix;
    }
    while( val );
 
 
    if( IsMinu )
    {
        pDest[ 0 ] = '-';
        for( int i = 0; i < count; ++i )
        {
            pDest[ i + 1 ] = '0' + buffer[ count - i - 1 ];
        }
        pDest[ count + 1 ] = '\0';
    }
    else
    {
        for( int i = 0; i < count; ++i )
        {
            pDest[ i ] = '0' + buffer[ count - i - 1 ];
        }
        pDest[ count ] = '\0';
    }
    return pDest;
}


23.如何判断链表是否有环
 

bool IsLoop( Node *pHead )
{
    //[H->A->B->C->A]
    assert( NULL != pHead );
    Node *pNext = pHead->mpNext;
    Node *pNextNext = pHead->mpNext;
    while( NULL != pNext && NULL != pNextNext->mpNext )
    {
        pNext = pNext->mpNext;//[ B、C、A ]
        pNextNext = pNextNext->mpNext->mpNext;//[C、B、A]
        if( pNext == pNextNext )
        {
            return true;
        }
    }
    return false;
}


24.统计出一个字符串每种字母出现的次数要求时间复杂度为O(n)

void CountLetter( const char *pSrc )
{
    int count[ 256 ] = {};
    for( ; *pSrc !='\0'; ++pSrc )
    {
        const char &c = *pSrc;
        if( ( c < 'A' || c > 'z') && ( c < 'a' || c > 'z' ) )
        {
            continue;
        }
        ++count[ c ];
    }
} 


25.选择排序的思想是什么？( 每次找到最大或最小的值放在数组的低位上 )请实现它
 

void SelectSort( int *pArray, int count )
{
    for( int i = 0; i < count; ++i )
    {
        //默认低位元素最小
        int MinValue = pArray[ i ];
        //默认保存低位元素的索引
        int MinIndex = i;
        //除开第一个元素找是否还有比它还小的元素( 升序 )
        for( int j = i + 1; j < count; ++j )
        {
            //发现找到比它还小的元素重新赋值和保存索引
            if( pArray[ j ] < MinValue )
            {
                MinValue = pArray[ j ];
                MinIndex = j;
            }
        }
        //将找到最小元素放在数组低位上面
        const int Temp = pArray[ i ];
        pArray[ i ] = MinValue;
        pArray[ MinIndex ] = Temp;
    }
}


 
26.冒泡排序的思想是什么?(升序排序中越小的数往低位走，越大的数往高位走,每次与相邻元素比较导致的特点)请实现它
 

void BubbleSort( int *pArray, int count )
{
    //eg.[6][8][8][0][9][1]
    //i = 0,j < 5    [6][8][0][8][1][9]
    //i = 1,j < 4    [6][0][8][1][8][9]
    //i = 2,j < 3    [0][6][1][8][8][9]
    //i = 3,j < 2    [0][1][6][8][8][9]
 
    //到此为止已经排序OK了
    //i = 4,j < 1    [0][1][6][8][8][9]
    //i = 5,j < 0    [0][1][6][8][8][9]
    for( int i = 0; i < count; ++i )
    {
        for( int j = 0; j < count - i - 1; ++j )
        {
            if( pArray[ j ] > pArray[ j + 1 ] )
            {
                const int Temp = pArray[ j ];
                pArray[ j ] = pArray[ j + 1 ];
                pArray[ j + 1 ] = Temp;
            }
        }
    }
}


 
27.已知两个数组有序实现一个方法将他们合并后任然有序
 

void MergeSort( int *pMerge, int *p1, int p1len, int *p2, int p2len )
{
    assert( nullptr != pMerge && nullptr != p1 && nullptr != p2 );
    int i = 0;
    int j = 0;
    int k = 0;
    while( i < p1len && j < p2len )
    {
        if( p1[ i ] < p2[ j ] )
        {
            pMerge[ k ] = p1[ i ];
            ++k;
            ++i;
        }
        else
        {
            pMerge[ k ] = p2[ j ];
            ++k;
            ++j;
        }
    }
    while( i < p1len )
    {
        pMerge[ k ] = p1[ i ];
        ++k;
        ++i;
    }
    while( j < p2len )
    {
        pMerge[ k ] = p2[ j ];
        ++k;
        ++j;
    }
}


 
28.实现一个算法找到数组中第二大的数
 

int FindSec( int *p, int len )
{
    assert( nullptr != p );
    int maxv = p[ 0 ];
    int secv = p[ 0 ];
    for( int i = 1; i < len; ++i )
    {
        if( maxv < p[ i ] )
        {
            secv = maxv;
            maxv = p[ i ];
        }
    }
    return secv;
}


 

ooMelloo
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++算法之——常用算法总结
dizhi5320的博客
02-19 1489
基本的C++算法分为三类：排序算法、树算法、图算法 算法思想有三种：递推、分治、动态规划 以及 贪心算法。 本文将简要介绍上面三类算法，介绍时穿插介绍算法思想。 一、排序算法 1、基本O(n^2)排序算法： （对基本排序算法的时间复杂度分析主要考虑 比较次数、数据交换次数） 冒泡排序：针对数组、本地排序、需要交换数据。O(1)额外空间 选择排序：一般针对数组、本...
C++算法大全及面试题详解
05-10
C++算法大全及面试题详解资料包包含两个word文档，一个C++算法大全，一个C++面试经典题及答案详解（包含大量代码）。这两份资料整理了C++的常见算法、常见考点和重要知识技巧，内容齐全，涵盖各类应试考点，满满干货（代码里程多）。这份精细资料旨在为大家面试面试C++程序员或算法工程师提供一些有用参考。
C++常见算法有哪些
u013083044的博客
03-31 883
std::cout << "从节点 " << start << " 到节点 " << i << " 的最短距禿：" << dist[i] << std::endl;std::cout << "目标值在数组中的索引为：" << index << std::endl;std::cout << "目标值在数组中的索引为：" << index << std::endl;std::cout << "最小生成树的总权值为：" << minCost << std::endl;std::cout << "未找到目标值。
C++基础面试题
矩阵实验室
11-11 1269
const符号常量： （1）、const char *p （2）、char const *p （3）、char * const p 如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量。 如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。 析构函数和虚函数的用法和作用？ 析构函数的作用是当对象生命期结束时释放对象所占用
C++面试算法题
qq_45620703的博客
06-30 1558
1、实现strcpy(字符串拷贝) 2、实现strcat(字符串连接) 3、实现字符串逆序 4、C语言中字符串转数字的方法是什么( atoi )，请实现它 5、实现一个将字符串中所有字母转换为大写的方法 6、判断X年X月X日是这年的第几天 7、删除链表中值为Value的所有元素( [Head]->[node1]->[node2]->…[noden] ) 8、实现strncpy 9、在母字符串中查找子字符串出现的次数 10、给定一个字符串，按单词将该字符串逆序，比如给定"This is a
c++经典算法面试题
qq_26938759的博客
04-03 1929
1.链表逆序 2.链表合并 3.一棵树是否某条路径结点之和等于给定值。并描述算法复杂度 4.你熟悉的排序算法并描述算法复杂度。 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 快速排序 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 归并排序 &nbsp;&nbsp
用C/C++实现的各种经典算法以及常见面试题
03-22
用C/C++实现的各种经典算法以及常见面试题
C++、C语言基础知识点强化，以及相关经典面试题、数据结构和算法知识及相关面试题汇总。
05-24
C++、C语言基础知识点强化，以及相关经典面试题、数据结构和算法知识及相关面试题汇总。更多请参考：https://luoyayun361.blog.csdn.net/article/details/123289250?spm=1001.2014.3001.5502 ...
C++面试题笔试题C++ 数据结构算法笔试题资料合集.zip
04-09
C++经典面试题库 附带参考答案.docx C++语言程序设计试题.docx CC++面试问题分类大汇总.docx C_C++笔试题大全.doc gamesloft C++面试题目.docx 常见C++笔试题目整理（含答案）.docx 经典C++面试题.docx 近期出现的...
C++笔试面试题汇总
08-20
本资源内包含：C++笔试题集锦（排版后），C语言基础总结，C经典算法100例、华为笔试题，C指针详解、C难点分析等7个文件。
c++面试常见算法总结
11-20
c++面试中常见的算法总结，对应届生非常有用！
C++ JAVA 计算机笔试面试真题复习资料BAT谷歌微软等各IT公司互联网面试笔试资料库合集（108个）.zip
最新发布
05-10
C++ JAVA 计算机笔试面试真题复习资料BAT谷歌微软等各...C++经典面试题库 附带参考答案.docx C++语言程序设计试题.docx C++面试题笔试题 CC++面试问题分类大汇总.docx C语言 gamesloft C++面试题目.docx Google笔试面试
C++面试题算法
weixin_30951743的博客
06-28 106
#include <iostream> #include <string> using namespace std ; /* 题目：给一个字符串、例如 “ababc”要求返回“ab”. 因为“ab”连续重复出现且最长。 用C/C＋＋语言写一函数完成该算法，给出复杂度 这道题的最终目的是找到最长的连续字符串 */ struct SubSt...
C++开发常见算法和数据结构面试题（持续更新）
fanhuashuiyue的博客
06-08 2499
1.给定一个单向链表（长度未知），请设计一个既节省时间又节省空间的算法来找出该链表中的倒数第m个元素。实现这个算法，并为可能出现的特例情况安排好处理措施。“倒数第m个元素”是这样规定的：当m=0时，链表的最后一个元素将被返回。 解决问题方法思路如下： 方法（双指针法）：头结点指针为当前指针，尾节点指针为拖后指针。开始的时候当前指针和拖后指针初始化为链表的头结点，首先我们让当前指针遍历到第m个元素，拖后指针不变；然后同步更新当前指针和拖后指针；直到当前指针为链表结尾。这样我们就能保证当前指针和拖尾指针之间的距
C++--入门算法题(1)
我有一颗薄荷糖的博客
09-23 348
提示：本文为学习记录，若有错误，私聊作者，谦虚受教。 文章目录入门算法题一、反向输出四位数二、反转字符串三、螺旋矩阵四、判断回文五、判断两个数的大小六、判断辅音还是元音七、缺失数字八、十六进制+八进制之和九、十六进制转换十进制十、puts函数输出字符串总结 入门算法题 我们一定要说积极向上的话。 只要持续使用非常积极的话语，就能积累起相关的重要信息，于是在不经意之间，我们就已经行动起来，并且逐渐把说过的话变成现实。 一、反向输出四位数 #include <bits/stdc++.h> us
几种面试常见的算法(C++实现)
何处寻欢
02-19 2017
#include &lt;iostream&gt; using namespace std; void quickSort(int s[], int left, int right) //快速排序 { if (left &lt; right) { int i = left, j = right, x = s[left]; while (i &lt; j)...
C++经典面试算法题
峻峰飞阳的博客 blog.csdn.net/while0
07-11 624
#include <assert.h> #include <string.h> #include <stack> //1.实现strcpy. char* MyStrCpy( char *pDest, const char *pSrc ) { if( nullptr == pDest || nullptr == pSrc ) ...
c++ 算法实战面试题
07-06
C算法实战面试题可以是各种类型和难度的问题，从简单的数组操作到复杂的图算法。下面是一个可能的题目： 假设有一个数组num，其中包含了一些整数。请编写一个算法，找到数组中两个元素的和等于给定的目标数的索引，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值