99道C++编程面试题整理

1. 编写一个程序实现二分搜索

回答

#include <iostream>
#include <vector>

using namespace std;

// 二分搜索函数
int binarySearch(const vector<int>& arr, int target) {
    
    
    int left = 0;
    int right = arr.size() - 1;

    while (left <= right) {
    
    
        int mid = left + (right - left) / 2;  // 防止溢出

        if (arr[mid] == target) {
    
    
            return mid;  // 找到目标值，返回索引
        } else if (arr[mid] < target) {
    
    
            left = mid + 1;  // 目标在右边
        } else {
    
    
            right = mid - 1;  // 目标在左边
        }
    }

    return -1;  // 未找到目标值，返回 -1
}

int main() {
    
    
    vector<int> arr = {
    
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10};  // 已排序的数组
    int target;

    cout << "请输入要查找的数字: ";
    cin >> target;

    int result = binarySearch(arr, target);

    if (result != -1) {
    
    
        cout << "数字 " << target << " 在数组中的索引为: " << result << endl;
    } else {
    
    
        cout << "数字 " << target << " 不在数组中。" << endl;
    }

    return 0;
}

代码解释：

1. binarySearch 函数：这个函数接受一个整数数组和一个目标值，并返回目标值在数组中的索引。如果未找到目标值，则返回 -1。

   • 使用两个指针 left 和 right 表示当前查找的范围。
   • 在循环中计算 mid 指针，检查中间值。
   • 根据中间值与目标值的比较结果，调整查找范围。

2. main 函数：

   • 定义一个已排序的整数数组。
   • 从标准输入获取用户想要查找的数字。
   • 调用 binarySearch 函数并输出结果。

注意：

• 二分搜索要求数组必须是已排序的。
• 该算法的时间复杂度为 O(log n)，比线性搜索 O(n) 更高效。

2. 编写一个程序来找出前N个自然数的和

回答

// C++ 程序找出前N个自然数的和
#include <iostream>
using namespace std;

// 函数来找出和
int findSum(int n) {
    
    
    int sum = 0;
    for (int i = 1; i <= n; i++)
        sum = sum + i;
    return sum;
}

int main() {
    
    
    int n = 7;
    cout << findSum(n);
    return 0;
}

输出

28

3. 编写一个程序实现编译时多态或函数重载

回答

在C++中，编译时多态通常是通过函数重载或模板实现的。下面我提供一个使用函数重载的简单示例。

示例：函数重载

这个例子展示了如何使用函数重载来实现编译时多态。我们将定义一个简单的加法函数，以处理不同类型的参数（整数和浮点数）。

#include <iostream>

// 加法函数重载 - 整数版本
int add(int a, int b) {
    
    
    return a + b;
}

// 加法函数重载 - 浮点数版本
double add(double a, double b) {
    
    
    return a + b;
}

// 加法函数重载 - 整数和浮点数混合版本
double add(int a, double b) {
    
    
    return a + b;
}

// 加法函数重载 - 浮点数和整数混合版本
double add(double a, int b) {
    
    
    return a + b;
}

int main() {
    
    
    int intResult = add(5, 10);  // 调用整数版本
    double doubleResult = add(3.5, 2.5); // 调用浮点数版本
    double mixedResult1 = add(5, 3.5); // 调用整数和浮点数混合版本
    double mixedResult2 = add(3.5, 5); // 调用浮点数和整数混合版本

    std::cout << "Integer addition: " << intResult << std::endl;
    std::cout << "Double addition: " << doubleResult << std::endl;
    std::cout << "Mixed addition (int + double): " << mixedResult1 << std::endl;
    std::cout << "Mixed addition (double + int): " << mixedResult2 << std::endl;

    return 0;
}

编译与运行

你可以将上述代码复制到一个 C++ 源文件（如 main.cpp）中，然后使用以下命令编译并运行：

g++ main.cpp -o main
./main

输出示例

运行程序后，输出结果将类似于以下内容：

Integer addition: 15
Double addition: 6
Mixed addition (int + double): 8.5
Mixed addition (double + int): 8.5

总结

在这个示例中，我们通过函数重载实现了编译时多态。我们定义了多个名为 add 的函数，但为了支持不同的数据类型和参数组合，分别提供了不同的实现。这允许我们在调用时，根据传入参数的类型选择正确的函数。

4. 编写一个程序来检查两个字符串是否为变位词

回答

变位词是指两个字符串中字符的出现次数相同但顺序不同的字符串。我们可以通过排序字符串或者使用哈希表（数组）来检查两个字符串是否为变位词。下面是一个使用哈希表（数组）的方法的C++程序示例：

#include <iostream>
#include <string>
#include <vector>

bool areAnagrams(const std::string &str1, const std::string &str2) {
    
    
    // 如果长度不同，则不可能是变位词
    if (str1.length() != str2.length()) {
    
    
        return false;
    }

    // 创建一个大小为256的数组来存储每个字符的出现次数
    std::vector<int> charCount(256, 0);

    // 统计第一个字符串中的字符频率
    for (char c : str1) {
    
    
        charCount[c]++;
    }

    // 递减第二个字符串中的字符频率
    for (char c : str2) {
    
    
        charCount[c]--;
        if (charCount[c] < 0) {
    
     // 如果有字符频率为负，说明不是变位词
            return false;
        }
    }

    return true; // 两个字符串是变位词
}

int main() {
    
    
    std::string str1, str2;

    std::cout << "请输入第一个字符串: ";
    std::cin >> str1;
    std::cout << "请输入第二个字符串: ";
    std::cin >> str2;

    if (areAnagrams(str1, str2)) {
    
    
        std::cout << str1 << " 和 " << str2 << " 是变位词。" << std::endl;
    } else {
    
    
        std::cout << str1 << " 和 " << str2 << " 不是变位词。" << std::endl;
    }

    return 0;
}

说明

1. 长度检查：首先，我们检查两个字符串的长度。如果长度不同，直接返回false。
2. 字符计数：使用一个大小为256的数组（假设我们处理的是ASCII字符集），来记录第一个字符串中每个字符的出现次数。
3. 比较频率：遍历第二个字符串，递减对应字符的频率。如果任何字符的频率变为负值，说明第二个字符串中有多余的字符，不是变位词。
4. 结果输出：根据返回值输出结果。

使用方法

• 将代码复制到C++编译器中进行编译和运行。
• 输入两个字符串，程序会返回它们是否为变位词的结果。

5. 编写一个C++程序检查数字是正数还是负数。

回答

以下是一个简单的C++程序，用于检查一个数字是正数、负数还是零。

#include <iostream>

int main() {
    
    
    double number; // 声明一个变量来存储输入的数字

    // 提示用户输入一个数字
    std::cout << "请输入一个数字: ";
    std::cin >> number; // 从用户输入读取数字

    // 检查数字是正数、负数还是零
    if (number > 0) {
    
    
        std::cout << "该数字是正数。" << std::endl;
    } else if (number < 0) {
    
    
        std::cout << "该数字是负数。" << std::endl;
    } else {
    
    
        std::cout << "该数字是零。" << std::endl;
    }

    return 0; // 返回0表示程序正常结束
}

代码解释：

• #include <iostream>：引入输入输出库。
• double number;：定义一个双精度浮点数变量来存储输入的数字。
• std::cin >> number;：获取用户输入的数字。
• 使用 if、else if 和 else 判断输入数字的状态，并输出相应的结果。

6. 编写一个程序来检查给定的字符串是否为回文

回答

#include <iostream>
#include <string>
#include <algorithm>

bool isPalindrome(const std::string& str) {
    
    
    // 创建一个只包含字母数字字符的新字符串，并将其转换为小写
    std::string filteredStr;
    for (char c : str) {
    
    
        if (std::isalnum(c)) {
    
    
            filteredStr += std::tolower(c);
        }
    }

    // 使用双指针方法检查回文
    int left = 0;
    int right = filteredStr.size() - 1;

    while (left < right) {
    
    
        if (filteredStr[left] != filteredStr[right]) {
    
    
            return false;
        }
        left++;
        right--;
    }

    return true;
}

int main() {
    
    
    std::string input;
    std::cout << "请输入字符串：";
    std::getline(std::cin, input);

    if (isPalindrome(input)) {
    
    
        std::cout << "该字符串是回文。" << std::endl;
    } else {
    
    
        std::cout << "该字符串不是回文。" << std::endl;
    }

    return 0;
}

说明

1. 过滤字符：程序首先将输入字符串中的非字母和数字字符去掉，并将所有字母转换为小写，以便于比较。
2. 双指针法：使用两个指针从字符串的两端向中间扫描，检查每对字符是否相同。
3. 输入和输出：程序会请求用户输入一个字符串，并输出该字符串是否为回文。

你可以将这段代码复制到你的 C++ 编辑器中进行编译和运行。

7. 编写一个程序来判断数字是否为质数

回答

// C++ 程序判断数字是否为质数
#include <iostream>
using namespace std;

bool isPrime(int n) {
    
    
    // 基础条件
    if (n <= 1)
        return false;
    // 检查从 2 到 n-1
    for (int i = 2; i < n; i++)
        if (n % i == 0)
            return false;
    return true;
}

int main() {
    
    
    isPrime(21) ? cout << " true\n" : cout << " false\n";
    isPrime(17) ? cout << " true\n" : cout << " false\n";
    return 0;
}

输出

false
true

8. 程序执行插入、删除和打印操作双向链表

回答

// C++ 程序实现插入、删除和打印
// 操作在双向链表
#include <iostream>
using namespace std;

struct Node {
    
    
    int data;
    Node* next;
    Node* prev;
};

class DoublyLinkedList {
    
    
private:
    Node* head;
public:
    DoublyLinkedList() : head(NULL) {
    
    
    }
    // 函数在开始处插入元素
    void insertAtStart(int data) {
    
    
        Node* newNode = new Node;
        newNode->data = data;
        newNode->next = head;
        newNode->prev = NULL;
        if (head != NULL)
            head->prev = newNode;
        head = newNode;
    }
    // 函数删除节点
    void deleteNode(int data) {
    
    
        Node* temp = head;
        while (temp != NULL && temp->data != data)
            temp = temp->next;
        if (temp == NULL)
            return;
        if (temp->prev != NULL)
            temp->prev->next = temp->next;
        else
            head = temp->next;
        if (temp->next != NULL)
            temp->next->prev = temp->prev;
        delete temp;
    }
    // 函数打印列表
    void printList() {
    
    
        Node* temp = head;
        while (temp != NULL) {
    
    
            std::cout << temp->data << " ";
            temp = temp->next;
        }
        std::cout << std::endl;
    }
};

int main() {
    
    
    DoublyLinkedList dll;
    dll.insertAtStart(1);
    dll.insertAtStart(2);
    dll.insertAtStart(3);
    dll.insertAtStart(4);
    dll.insertAtStart(5);
    std::cout << "Original Doubly Linked List: ";
    dll.printList();
    dll.deleteNode(2);
    std::cout << "Doubly Linked List after deletion: ";
    dll.printList();
    return 0;
}

输出

Original Doubly Linked List: 5 4 3 2 1
Doubly Linked List after deletion: 5 4 3 1

9. 编写一个程序来计算数组中元素的和

回答

// C++ 程序计算数组中元素的和
#include <iostream>
using namespace std;

int sum(int arr[], int n) {
    
    
    int sum = 0;
    for (int i = 0; i < n; i++)
        sum += arr[i];
    return sum;
}

int main() {
    
    
    int arr[] = {
    
     1, 23, 54, 12, 9 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Sum: " << sum(arr, n);
    return 0;
}

输出

Sum: 99

10. 编写一个程序来检查字符是元音还是辅音

回答

#include <iostream>

using namespace std;

int main() {
    
    
    char ch;
    
    cout << "请输入一个字符: ";
    cin >> ch;

    // 将字符转换为小写，方便比较
    ch = tolower(ch);

    // 检查输入是否是字母
    if (isalpha(ch)) {
    
    
        // 检查元音
        if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') {
    
    
            cout << ch << " 是一个元音。" << endl;
        } else {
    
    
            cout << ch << " 是一个辅音。" << endl;
        }
    } else {
    
    
        cout << "输入的字符不是一个字母。" << endl;
    }

    return 0;
}

程序说明：

1. 程序首先要求用户输入一个字符。
2. 使用 tolower 函数将字符转换为小写，以简化元音和辅音的比较。
3. 使用 isalpha 函数检查输入是否为字母。
4. 根据用户输入的字符，判断它是否是元音或辅音，并输出相应的结果。

---

由于篇幅限制，查看全部题目，请访问：C++编程面试题库