Top100 C++编程面试问题

本文为新手以及有经验的专业人士提供了一个C++编程面试问题列表。这些问题旨在测试候选者对以下主题的理解：

C++语法及语义
数据结构和算法
面向对象编程
内存管理
指针
模板

文章目录

[1. 编写程序判断数字是正数还是负数](#1. 编写程序判断数字是正数还是负数)
[2. 编写程序找出三个数中最大的一个](#2. 编写程序找出三个数中最大的一个)
[3. 编写程序检查数字是偶数还是奇数](#3. 编写程序检查数字是偶数还是奇数)
[4. 编写程序计算字符的ASCII值](#4. 编写程序计算字符的ASCII值)
[5. 编写程序检查字符是元音还是辅音](#5. 编写程序检查字符是元音还是辅音)
[6. 编写程序检查一个字符是否为字母表](#6. 编写程序检查一个字符是否为字母表)
[7. 编写程序，在不使用 strlen()函数的情况下计算字符串的长度](#7. 编写程序，在不使用 strlen()函数的情况下计算字符串的长度)
[8. 编写程序来切换字符串中的每个字符](#8. 编写程序来切换字符串中的每个字符)
[9. 编写程序来统计元音的数量](#9. 编写程序来统计元音的数量)
[10. 编写程序删除字符串中的元音](#10. 编写程序删除字符串中的元音)
[11. 编写程序删除字符串中除字母以外的所有字符](#11. 编写程序删除字符串中除字母以外的所有字符)
[12. 编写程序删除字符串中的空格](#12. 编写程序删除字符串中的空格)
[13. 编写程序求前N个自然数的和](#13. 编写程序求前N个自然数的和)
[14. 编写一个用循环求数的阶乘的程序](#14. 编写一个用循环求数的阶乘的程序)
[15. 编写程序判断是否为闰年](#15. 编写程序判断是否为闰年)
[16. 编写程序判断是否为素数](#16. 编写程序判断是否为素数)
[17. 编写程序检查是否为回文](#17. 编写程序检查是否为回文)
[18. 编写程序检查一个数字是否为Armstrong数](#18. 编写程序检查一个数字是否为Armstrong数)
[19. 编写程序计算斐波那契数列的第N项](#19. 编写程序计算斐波那契数列的第N项)
[20. 编写程序计算两个数的最大公约数](#20. 编写程序计算两个数的最大公约数)
[21. 编写程序计算两个数字的最小公倍数（LCM）](#21. 编写程序计算两个数字的最小公倍数（LCM）)
[22. 编写程序求二次方程的根](#22. 编写程序求二次方程的根)
[23. 编写程序查找数组中的最小和最大的元素](#23. 编写程序查找数组中的最小和最大的元素)
[24. 编写程序查找数组中第二小的元素](#24. 编写程序查找数组中第二小的元素)
[25. 编写程序计算数组所有元素的和](#25. 编写程序计算数组所有元素的和)
[26. 编写程序检查给定字符串是否为回文](#26. 编写程序检查给定字符串是否为回文)
[27. 编写程序检查两个字符串是否互为异位字符串](#27. 编写程序检查两个字符串是否互为异位字符串)
[28. 编写程序打印以下的钻石图案](#28. 编写程序打印以下的钻石图案)
[29. 编写打印金字塔图案的程序](#29. 编写打印金字塔图案的程序)
[30. 编写程序打印沙漏图案](#30. 编写程序打印沙漏图案)
[31. 编写程序打印旋转沙漏图案](#31. 编写程序打印旋转沙漏图案)
[32. 编写打印简单金字塔图案的程序](#32. 编写打印简单金字塔图案的程序)
[33. 编写程序打印倒金字塔](#33. 编写程序打印倒金字塔)
[34. 编写程序打印三角形星形图案](#34. 编写程序打印三角形星形图案)
[35. 编写程序打印Floyd三角形](#35. 编写程序打印Floyd三角形)
[36. 编写程序打印Pascal三角形](#36. 编写程序打印Pascal三角形)
[37. 编写程序逆序打印给定字符串](#37. 编写程序逆序打印给定字符串)
[38. 编写C++程序，使用递归逆序打印给定字符串](#38. 编写C++程序，使用递归逆序打印给定字符串)
[39. 编写程序，使用递归判断给定的字符串是否为回文](#39. 编写程序，使用递归判断给定的字符串是否为回文)
[40. 使用递归计算字符串长度](#40. 使用递归计算字符串长度)
[41. 使用递归计算一个数的阶乘](#41. 使用递归计算一个数的阶乘)
[42. 编写程序计算字符串中数字的总和](#42. 编写程序计算字符串中数字的总和)
[43. 编写一个程序，在不使用分号的情况下打印N以内的所有自然数](#43. 编写一个程序，在不使用分号的情况下打印N以内的所有自然数)
[44. 编写一个程序，在不使用任何额外变量的情况下交换两个变量的值](#44. 编写一个程序，在不使用任何额外变量的情况下交换两个变量的值)
[45. 编写程序，使用补码(~)运算符打印无符号整数类型的最大值](#45. 编写程序，使用补码(~)运算符打印无符号整数类型的最大值)
[46. 不使用算术或比较运算符，检查两个数字的相等性](#46. 不使用算术或比较运算符，检查两个数字的相等性)
[47. 编写一个程序，在不使用比较运算符的情况下求两个数的最大值和最小值](#47. 编写一个程序，在不使用比较运算符的情况下求两个数的最大值和最小值)
[48. 编写八进制到十进制转换程序](#48. 编写八进制到十进制转换程序)
[49. 编写十六进制到十进制转换的程序](#49. 编写十六进制到十进制转换的程序)
[50. 编写一个十进制到二进制转换的程序](#50. 编写一个十进制到二进制转换的程序)
[51. 编写一个程序进行十进制八进制转换](#51. 编写一个程序进行十进制八进制转换)
[52. 编写十进制到十六进制转换程序](#52. 编写十进制到十六进制转换程序)
[53. 编写二进制到八进制转换程序](#53. 编写二进制到八进制转换程序)
[54. 编写八进制到二进制转换的程序](#54. 编写八进制到二进制转换的程序)
[55. 编写一个程序来实现封装的使用](#55. 编写一个程序来实现封装的使用)
[56. 编写一个实现抽象概念的程序](#56. 编写一个实现抽象概念的程序)
[57. 编写程序实现编译时多态性或函数重载的概念](#57. 编写程序实现编译时多态性或函数重载的概念)
[58. 编写一个实现运算符重载概念的程序](#58. 编写一个实现运算符重载概念的程序)
[59. 编写一个程序来实现函数重写或运行时多态性的概念](#59. 编写一个程序来实现函数重写或运行时多态性的概念)
[60. 编写实现单继承的程序](#60. 编写实现单继承的程序)
[61. 编写程序创建一个复数类](#61. 编写程序创建一个复数类)
[62. 编写一个程序来实现英寸-英尺系统](#62. 编写一个程序来实现英寸-英尺系统)
[63. 编写程序实现冒泡排序](#63. 编写程序实现冒泡排序)
[64. 编写程序实现插入排序](#64. 编写程序实现插入排序)
[65. 编写程序以实现选择排序](#65. 编写程序以实现选择排序)
[66. 编写程序实现归并排序](#66. 编写程序实现归并排序)
[67. 编写程序实现快速排序](#67. 编写程序实现快速排序)
[68. 编写程序实现线性搜索](#68. 编写程序实现线性搜索)
[69. 编写一个程序实现二分查找](#69. 编写一个程序实现二分查找)
[70. 编写一个程序来查找vector中给定元素的下标](#70. 编写一个程序来查找vector中给定元素的下标)
[71. 编写程序，使用STL删除数组中重复的元素](#71. 编写程序，使用STL删除数组中重复的元素)
[72. 用STL编写数组降序排序程序](#72. 用STL编写数组降序排序程序)
[73. 编写程序计算给定字符串中每个单词的频率](#73. 编写程序计算给定字符串中每个单词的频率)
[74. 编写一个程序，按原始顺序查找数组最大的 k 个元素](#74. 编写一个程序，按原始顺序查找数组最大的 k 个元素)
[75. 编写一个程序，使用STL找出给定集合的所有不同子集](#75. 编写一个程序，使用STL找出给定集合的所有不同子集)
[76. 编写一个程序遍历一个队列，但不删除其中的元素](#76. 编写一个程序遍历一个队列，但不删除其中的元素)
[77. 编写一个程序，使用数组实现栈](#77. 编写一个程序，使用数组实现栈)
[78. 编写一个程序，使用数组实现队列](#78. 编写一个程序，使用数组实现队列)
[79. 编写程序使用队列实现栈](#79. 编写程序使用队列实现栈)
[80. 用STL中的链表写一个程序来实现栈](#80. 用STL中的链表写一个程序来实现栈)
[81. 编写一个程序，判断一个数组是否是另一个数组的子集](#81. 编写一个程序，判断一个数组是否是另一个数组的子集)
[82. Write a Program for Finding the Circular Rotation of an Array by K Positions](#82. Write a Program for Finding the Circular Rotation of an Array by K Positions)
[83. 编写一个程序，按升序对前半部分进行排序，按降序对后半部分进行排序](#83. 编写一个程序，按升序对前半部分进行排序，按降序对后半部分进行排序)
84.编写程序逆序打印给定字符串
[85. 编写一个程序，使用递归打印一个字符串的所有排列](#85. 编写一个程序，使用递归打印一个字符串的所有排列)
[86. 编写一个程序，按字典序打印给定字符串的所有排列](#86. 编写一个程序，按字典序打印给定字符串的所有排列)
[87. 编写一个程序，删除代数表达式中的括号](#87. 编写一个程序，删除代数表达式中的括号)
[88. 对单链表执行插入、删除和打印操作](#88. 对单链表执行插入、删除和打印操作)
[89. 对双链表执行插入、删除和打印操作](#89. 对双链表执行插入、删除和打印操作)
[90. 对循环链表执行插入、删除和打印操作](#90. 对循环链表执行插入、删除和打印操作)
[91. 二叉树的中序遍历](#91. 二叉树的中序遍历)
[92. 编写程序求一组正整数的所有子集](#92. 编写程序求一组正整数的所有子集)
[93. 二叉树的先序遍历](#93. 二叉树的先序遍历)
[94. 二叉树的后序遍历](#94. 二叉树的后序遍历)
[95. 二叉树的层级遍历](#95. 二叉树的层级遍历)
[96. 编写程序打印二叉树的俯视图](#96. 编写程序打印二叉树的俯视图)
[97. 编写程序打印二叉树的仰视图](#97. 编写程序打印二叉树的仰视图)
[98. 编写程序打印二叉树的左视图](#98. 编写程序打印二叉树的左视图)
[99. 编写程序打印二叉树的右视图](#99. 编写程序打印二叉树的右视图)
[100. 编写程序将中缀表达式转换为后缀表达式](#100. 编写程序将中缀表达式转换为后缀表达式)

1. 编写程序判断数字是正数还是负数

cpp 复制代码

// C++ Program to check whether a number is positive or 
// negative 
#include <iostream> 
using namespace std; 

int main() 
{ 
	int number; 
	number = -100; 
	if (number >= 0) { 
		cout << number << " is a positive number." << endl; 
	} 
	else { 
		cout << number << " is a negative number." << endl; 
	} 
	return 0; 
}

输出：

bash 复制代码

-100 is a negative number.

2. 编写程序找出三个数中最大的一个

cpp 复制代码

// C++ program to find greatest 
// among three numbers using 
#include <iostream> 
using namespace std; 

int main() 
{ 
	int a = 10, b = 20, c = 30; 

	cout << "The Greatest Among Three Numbers is : "; 

	if (a >= b && a >= c) { 
		cout << a << endl; 
	} 
	else if (b >= a && b >= c) { 
		cout << b << endl; 
	} 
	else { 
		cout << c << endl; 
	} 
	return 0; 
}

输出：

bash 复制代码

The Greatest Among Three Numbers is : 30

3. 编写程序检查数字是偶数还是奇数

cpp 复制代码

// C++ program to check 
// for even or odd 
#include <iostream> 
using namespace std; 

// Returns true if n is 
// even, else odd 
bool isEven(int n) { return (n % 2 == 0); } 

// Driver code 
int main() 
{ 
	int n = 247; 
	if (isEven(n) == true) { 
		cout << "Even" << endl; 
	} 
	else { 
		cout << "Odd"; 
	} 

	return 0; 
}

输出：

bash 复制代码

Odd

4. 编写程序计算字符的ASCII值

cpp 复制代码

// C++ Program to find ASCII value of a character 
#include <iostream> 
using namespace std; 

int main() 
{ 
	char ch; 

	ch = 'A'; 

	cout << "The ASCII value of " << ch << " is " << int(ch) 
		<< endl; 

	return 0; 
}

输出：

bash 复制代码

The ASCII value of A is 65

5. 编写程序检查字符是元音还是辅音

cpp 复制代码

// C++ Program to print whether a character is vowel or not 
#include <cctype> 
#include <iostream> 
using namespace std; 

int main() 
{ 
	char ch = 'e'; 

	if (isalpha(ch)) { 
		if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o'
			|| ch == 'u' || ch == 'A' || ch == 'E'
			|| ch == 'I' || ch == 'O' || ch == 'U') { 
			cout << ch << " is a vowel." << endl; 
		} 
		else { 
			cout << ch << " is a consonant." << endl; 
		} 
	} 
	else { 
		cout << ch << " is not an alphabet." << endl; 
	} 

	return 0; 
}

输出：

bash 复制代码

e is a vowel.

6. 编写程序检查一个字符是否为字母表

cpp 复制代码

// C++ program to print whether a character is an alphabet 
// or not 
#include <cctype> 
#include <iostream> 
using namespace std; 

int main() 
{ 
	char ch; 

	ch = 'a'; 

	if (isalpha(ch)) { 
		cout << ch << " is an alphabet." << endl; 
	} 
	else { 
		cout << ch << " is not an alphabet." << endl; 
	} 

	return 0; 
}

输出：

bash 复制代码

a is an alphabet.

7. 编写程序，在不使用 `strlen()`函数的情况下计算字符串的长度

cpp 复制代码

// C++ Program to find the length of a string without using 
// strlen() 
#include <cstring> 
#include <iostream> 
using namespace std; 

int main() 
{ 
	string str = "GeeksforGeeks"; 
	int length = 0; 

	for (int i = 0; str[i] != '\0'; i++) { 
		length++; 
	} 

	cout << "The length of the string is: " << length 
		<< endl; 

	return 0; 
}

输出：

bash 复制代码

The length of the string is: 13

8. 编写程序来切换字符串中的每个字符

cpp 复制代码

// C++ Program to toggle string 
#include <cstring> 
#include <iostream> 
using namespace std; 

int main() 
{ 
	string str = "GeeksforGeeks"; 

	for (int i = 0; str[i] != '\0'; i++) { 
		if (islower(str[i])) { 
			str[i] = toupper(str[i]); 
		} 
		else if (isupper(str[i])) { 
			str[i] = tolower(str[i]); 
		} 
	} 

	cout << "Toggled string: " << str << endl; 

	return 0; 
}

输出：

bash 复制代码

Toggled string: gEEKSFORgEEKS

9. 编写程序来统计元音的数量

cpp 复制代码

// C++ Program to count the number of vowels 
#include <cstring> 
#include <iostream> 
using namespace std; 

int main() 
{ 
	string str = "GeeksforGeeks to the moon"; 
	int vowels = 0; 

	for (int i = 0; str[i] != '\0'; i++) { 
		if (str[i] == 'a' || str[i] == 'e' || str[i] == 'i'
			|| str[i] == 'o' || str[i] == 'u'
			|| str[i] == 'A' || str[i] == 'E'
			|| str[i] == 'I' || str[i] == 'O'
			|| str[i] == 'U') { 
			vowels++; 
		} 
	} 

	cout << "Number of vowels in the string: " << vowels 
		<< endl; 

	return 0; 
}

输出：

bash 复制代码

Number of vowels in the string: 9

10. 编写程序删除字符串中的元音

cpp 复制代码

// C++ Program to remove the vowels from a string 
#include <cstring> 
#include <iostream> 
using namespace std; 

int main() 
{ 
	int j = 0; 

	string str = "GeeksforGeeks"; 

	for (int i = 0; str[i] != '\0'; i++) { 
		if (str[i] != 'a' && str[i] != 'e' && str[i] != 'i'
			&& str[i] != 'o' && str[i] != 'u'
			&& str[i] != 'A' && str[i] != 'E'
			&& str[i] != 'I' && str[i] != 'O'
			&& str[i] != 'U') { 
			str[j++] = str[i]; 
		} 
	} 
	while (j < str.size()) { 

		str[j] = '\0'; 

		j++; 
	} 
	cout << "String without vowels: " << str << endl; 

	return 0; 
}

输出：

bash 复制代码

String without vowels: GksfrGks

11. 编写程序删除字符串中除字母以外的所有字符

cpp 复制代码

// C++ Programto remove all characters from a string except 
// alphabets 
#include <cctype> 
#include <iostream> 
#include <string> 

using namespace std; 

string remove_non_alphabets(string str) 
{ 
	string result = ""; 
	for (char c : str) { 
		if (isalpha(c)) { 
			result += c; 
		} 
	} 
	return result; 
} 

int main() 
{ 
	string str = "Gee$ksfor$geeks"; 

	cout << "Alphabets only: " << remove_non_alphabets(str) 
		<< endl; 

	return 0; 
}

输出：

bash 复制代码

Alphabets only: Geeksforgeeks

12. 编写程序删除字符串中的空格

cpp 复制代码

// C++ Program to remove spaces from a string 
#include <iostream> 
#include <string> 

using namespace std; 

string remove_spaces(string str) 
{ 
	string result = ""; 
	for (char c : str) { 
		if (c != ' ') { 
			result += c; 
		} 
	} 
	return result; 
} 

int main() 
{ 
	string str = "Gfg to the moon"; 

	cout << "Without spaces: " << remove_spaces(str) 
		<< endl; 

	return 0; 
}

输出：

bash 复制代码

Without spaces: Gfgtothemoon

13. 编写程序求前N个自然数的和

cpp 复制代码

// C++ program to find 
// Sum of first 
// n natural numbers. 
#include <iostream> 
using namespace std; 

// Function to find sum 
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; 
}

输出：

bash 复制代码

14. 编写一个用循环求数的阶乘的程序

cpp 复制代码

// C++ program to find factorial using loops 
#include <bits/stdc++.h> 
using namespace std; 

// function to find factorial 
int factorial(int n) 
{ 
	int fact = 1; 
	while (n > 1) { 
		fact *= n; 
		n--; 
	} 

	return fact; 
} 

// driver code 
int main() 
{ 
	int num = 5; 

	cout << factorial(num); 

	return 0; 
}

输出：

bash 复制代码

15. 编写程序判断是否为闰年

cpp 复制代码

// C++ program to check if a given 
// year is leap year or not 
#include <iostream> 
using namespace std; 

bool checkYear(int year) 
{ 
	// leap year 
	if (year % 400 == 0) 
		return true; 

	// Not leap year 
	if (year % 100 == 0) 
		return false; 

	// leap year 
	if (year % 4 == 0) 
		return true; 

	// Not leap year 
	return false; 
} 

int main() 
{ 
	int year = 2000; 

	if (checkYear(year)) 
		cout << "Leap Year"; 
	else
		cout << "Not a Leap Year"; 
	return 0; 
}

输出：

bash 复制代码

Leap Year

16. 编写程序判断是否为素数

cpp 复制代码

// C++ program to check if a 
// Number is prime 
#include <iostream> 
using namespace std; 

bool isPrime(int n) 
{ 
	// base condition 
	if (n <= 1) 
		return false; 

	// Check from 2 to 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; 
}

输出：

bash 复制代码

false
true

17. 编写程序检查是否为回文

cpp 复制代码

// C++ program to check if a 
// number is Palindrome or not 
#include <iostream> 
using namespace std; 

// Function to check Palindrome 
bool checkPalindrome(int n) 
{ 
	int ans = 0; 
	int temp = n; 
	while (temp != 0) { 
		ans = (ans * 10) + (temp % 10); 
		temp = temp / 10; 
	} 

	return (ans == n); 
} 

int main() 
{ 
	int n = 12321; 

	if (checkPalindrome(n) == 1) { 
		cout << "Yes\n"; 
	} 
	else { 
		cout << "No\n"; 
	} 

	return 0; 
}

输出：

bash 复制代码

Yes

18. 编写程序检查一个数字是否为Armstrong数

cpp 复制代码

// C++ Program to check 
// if number is Armstrong 
// or not 
#include <iostream> 
using namespace std; 

int main() 
{ 
	int n = 153; 
	int temp = n; 
	int ans = 0; 

	// function to calculate 
	// the sum of individual digits 
	while (n > 0) { 

		int rem = n % 10; 
		ans = (ans) + (rem * rem * rem); 
		n = n / 10; 
	} 

	// condition to check 
	if (temp == ans) { 
		cout << ("Yes, it is Armstrong Number"); 
	} 
	else { 
		cout << ("No, it is not an Armstrong Number"); 
	} 
	return 0; 
}

输出：

bash 复制代码

Yes, it is Armstrong Number

19. 编写程序计算斐波那契数列的第N项

cpp 复制代码

// C++ Program to Find the 
// Nth Term of the Fibonacci Series 
#include <iostream> 
using namespace std; 

int fib(int n) 
{ 
	int first = 0, second = 1, ans; 
	if (n == 0) 
		return first; 

	for (int i = 2; i <= n; i++) { 
		ans = first + second; 
		first = second; 
		second = ans; 
	} 

	return ans; 
} 

int main() 
{ 
	int n = 13; 

	cout << fib(n); 
	return 0; 
}

输出：

bash 复制代码

20. 编写程序计算两个数的最大公约数

cpp 复制代码

// C++ program to find 
// GCD of two numbers 
#include <iostream> 

using namespace std; 

// Function to return gcd of a and b 
int gcd(int a, int b) 
{ 
	int result = min(a, b); 

	while (result > 0) { 
		if (a % result == 0 && b % result == 0) { 
			break; 
		} 
		result--; 
	} 

	return result; 
} 

int main() 
{ 
	int a = 54, b = 33; 

	cout << "GCD: " << gcd(a, b); 

	return 0; 
}

输出：

bash 复制代码

GCD: 3

21. 编写程序计算两个数字的最小公倍数（LCM）

cpp 复制代码

// C++ program to 
// Find LCM of two numbers 
#include <iostream> 
using namespace std; 

long long gcd(long long int a, long long int b) 
{ 
	if (b == 0) 
		return a; 
	return gcd(b, a % b); 
} 

// Function to return LCM of two numbers 
long long lcm(int a, int b) 
{ 
	long long result = (a / gcd(a, b)) * b; 
	return result; 
} 

int main() 
{ 
	int a = 24, b = 13; 
	cout << "LCM : " << lcm(a, b); 
	return 0; 
}

输出：

bash 复制代码

LCM : 312

22. 编写程序求二次方程的根

cpp 复制代码

// C++ program to find 
// Roots of a quadratic equation 
#include <iostream> 
#include <math.h> 
using namespace std; 

// Prints roots of quadratic equation ax*2 + bx + c 
void findRoots(int a, int b, int c) 
{ 
	// If a is 0, then equation is not quadratic 
	if (a == 0) { 
		cout << "Invalid"; 
		return; 
	} 

	// Formulae to calculate D 
	int d = b * b - 4 * a * c; 

	// Formulae to calculate 
	// square root of D 
	double sqrt_val = sqrt(abs(d)); 

	// Conditons for checking root 
	if (d > 0) { 
		cout << "Roots are real and different \n"; 
		cout << (double)(-b + sqrt_val) / (2 * a) << "\n"
			<< (double)(-b - sqrt_val) / (2 * a); 
	} 
	else if (d == 0) { 
		cout << "Roots are real and same \n"; 
		cout << -(double)b / (2 * a); 
	} 
	else { 
		cout << "Roots are complex \n"; 
		cout << -(double)b / (2 * a) << " + i"
			<< sqrt_val / (2 * a) << "\n"
			<< -(double)b / (2 * a) << " - i"
			<< sqrt_val / (2 * a); 
	} 
} 

int main() 
{ 
	int a = 1, b = 4, c = 4; 

	findRoots(a, b, c); 

	return 0; 
}

输出：

bash 复制代码

Roots are real and same 
-2

23. 编写程序查找数组中的最小和最大的元素

cpp 复制代码

// C++ code to for 
// Finding the minimum 
// And maximum of the array 
#include <iostream> 
using namespace std; 

// Function to find the minimum 
// and maximum of the array 
void findMinMax(int arr[], int n) 
{ 
	int mini = arr[0]; 
	int maxi = arr[0]; 

	for (int i = 0; i < n; i++) { 
		if (arr[i] < mini) { 
			mini = arr[i]; 
		} 
		else if (arr[i] > maxi) { 
			maxi = arr[i]; 
		} 
	} 

	cout << "Min: " << mini << endl; 
	cout << "Max: " << maxi << endl; 
} 

int main() 
{ 
	int arr[] = { 1, 2, 3, 4, 5 }; 
	int N = sizeof(arr) / sizeof(arr[0]); 

	findMinMax(arr, N); 

	return 0; 
}

输出：

bash 复制代码

Min: 1
Max: 5

24. 编写程序查找数组中第二小的元素

cpp 复制代码

// C++ program to find 
// Second smallest elements 
#include <climits> 
#include <iostream> 
using namespace std; 

void print2Smallest(int arr[], int n) 
{ 
	int first, second; 

	if (n < 2) { 
		cout << " Invalid Input "; 
		return; 
	} 

	first = second = INT_MAX; 
	for (int i = 0; i < n; i++) { 
		// If current element is smaller than first 
		// Then update both first and second 
		if (arr[i] < first) { 
			second = first; 
			first = arr[i]; 
		} 

		// If arr[i] is in between first and second 
		// Then update second 
		else if (arr[i] < second && arr[i] != first) 
			second = arr[i]; 
	} 
	if (second == INT_MAX) 
		cout << "There is no second smallest element\n"; 
	else
		cout << " Second smallest element is " << second 
			<< endl; 
} 

int main() 
{ 
	int arr[] = { 21, 3, 15, 41, 34, 10 }; 
	int n = sizeof(arr) / sizeof(arr[0]); 

	print2Smallest(arr, n); 

	return 0; 
}

输出：

bash 复制代码

Second smallest element is 10

25. 编写程序计算数组所有元素的和

cpp 复制代码

// C++ Program to calculate 
// sum of elements in an array 
#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; 
}

输出：

bash 复制代码

Sum: 99

26. 编写程序检查给定字符串是否为回文

cpp 复制代码

// C++ program for checking 
// if it is Palindrome or not 
#include <iostream> 
using namespace std; 

string isPalindrome(string S) 
{ 
	for (int i = 0; i < S.length() / 2; i++) { 
		if (S[i] != S[S.length() - i - 1]) { 
			return "No"; 
		} 
	} 

	return "Yes"; 
} 

int main() 
{ 
	string S = "GeekeeG"; 

	cout << isPalindrome(S); 

	return 0; 
}

输出：

bash 复制代码

Yes

27. 编写程序检查两个字符串是否互为异位字符串

cpp 复制代码

// C++ program to check if two strings 
// Are anagrams of each other 
#include <iostream> 
using namespace std; 

#define NO_OF_CHARS 256 

bool areAnagram(char* str1, char* str2) 
{ 
	// Create 2 count arrays and initialize all values as 0 
	int count1[NO_OF_CHARS] = { 0 }; 
	int count2[NO_OF_CHARS] = { 0 }; 
	int i; 

	// For each character in input strings, increment count 
	// in the corresponding count array 
	for (i = 0; str1[i] && str2[i]; i++) { 
		count1[str1[i]]++; 
		count2[str2[i]]++; 
	} 

	if (str1[i] || str2[i]) 
		return false; 

	// Compare count arrays 
	for (i = 0; i < NO_OF_CHARS; i++) 
		if (count1[i] != count2[i]) 
			return false; 

	return true; 
} 

int main() 
{ 
	char str1[] = "Geek"; 
	char str2[] = "for"; 

	if (areAnagram(str1, str2)) 
		cout << "The two strings are anagram of each other"; 
	else
		cout << "The two strings are not anagram of each "
				"other"; 

	return 0; 
}

输出：

bash 复制代码

The two strings are not anagram of each other

28. 编写程序打印以下的钻石图案

             *
            ***
           *****
          *******
           *****
            ***
             *

cpp 复制代码

// C++ program to print 
// Diamond shape 
#include <iostream> 
using namespace std; 

void printDiamond(int n) 
{ 
	int space = n - 1; 

	for (int i = 0; i < n; i++) { 
		for (int j = 0; j < space; j++) 
			cout << " "; 

		// Print i+1 stars 
		for (int j = 0; j <= i; j++) 
			cout << "* "; 

		cout << endl; 
		space--; 
	} 

	space = 0; 

	// run loop (parent loop) 
	for (int i = n; i > 0; i--) { 
		for (int j = 0; j < space; j++) 
			cout << " "; 

		// Print i stars 
		for (int j = 0; j < i; j++) 
			cout << "* "; 

		cout << endl; 
		space++; 
	} 
} 

int main() 
{ 
	printDiamond(5); 
	return 0; 
}

输出：

bash 复制代码

    * 
   * * 
  * * * 
 * * * * 
* * * * * 
* * * * * 
 * * * * 
  * * * 
   * * 
    *

29. 编写打印金字塔图案的程序

bash 复制代码

              *
             ***
            *****
           *******

cpp 复制代码

// C++ Program to 
// Print Pyramid pattern 
#include <iostream> 
using namespace std; 

void pattern(int n) 
{ 
	int k = 2 * n - 2; 

	for (int i = 0; i < n; i++) { 

		for (int j = 0; j < k; j++) 
			cout << " "; 

		k = k - 1; 
		for (int j = 0; j <= i; j++) { 
			// Printing stars 
			cout << "* "; 
		} 
		cout << endl; 
	} 
} 

int main() 
{ 
	int n = 5; 

	pattern(n); 
	return 0; 
}

输出：

bash 复制代码

        * 
       * * 
      * * * 
     * * * * 
    * * * * *

30. 编写程序打印沙漏图案

bash 复制代码

* * * * * * * * *
  * * * * * * *
    * * * * *
      * * *
        *
      * * *    
    * * * * *
  * * * * * * *    
* * * * * * * * *

cpp 复制代码

// C Program to print hourglass pattern 
#include <iostream> 
using namespace std; 

// function to print hourglass pattern 
void hourglass(int rows) 
{ 

	// first outer loop to iterate each row 
	for (int i = 0; i < 2 * rows - 1; i++) { 

		// assigning comparator 
		int comp; 
		if (i < rows) { 
			comp = 2 * i + 1; 
		} 
		else { 
			comp = 2 * (2 * rows - i) - 3; 
		} 

		// first inner loop to print leading spaces 
		for (int j = 0; j < comp; j++) { 
			cout << ' '; 
		} 

		// second inner loop to print star * 
		for (int k = 0; k < 2 * rows - comp; k++) { 
			cout << "* "; 
		} 
		cout << '\n'; 
	} 
} 

int main() 
{ 
	hourglass(5); 
	return 0; 
}

输出：

bash 复制代码

 * * * * * * * * * 
   * * * * * * * 
     * * * * * 
       * * * 
         * 
       * * * 
     * * * * * 
   * * * * * * * 
 * * * * * * * * *

31. 编写程序打印旋转沙漏图案

bash 复制代码

*                         * 
* *                     * * 
* * *                 * * * 
* * * *             * * * * 
* * * * *         * * * * * 
* * * * * *     * * * * * * 
* * * * * * * * * * * * * * 
* * * * * *     * * * * * * 
* * * * *         * * * * * 
* * * *             * * * * 
* * *                 * * * 
* *                     * * 
*                         *

cpp 复制代码

// C++ Program to print 
// star pattern given 
#include <iostream> 
using namespace std; 

void pattern(int n) 
{ 
	for (int i = 0; i <= n; i++) { 
		for (int j = 0; j <= i; j++) { 
			cout << "* "; 
		} 

		int spaces = 2 * (n - i); 
		for (int j = 0; j < spaces; j++) { 
			cout << " "; 
		} 

		for (int j = 0; j <= i; j++) { 
			cout << "* "; 
		} 

		cout << endl; 
	} 

	// Printing bottom part. 
	for (int i = n - 1; i >= 0; i--) { 

		for (int j = 0; j <= i; j++) { 
			cout << "* "; 
		} 

		int spaces = 2 * (n - i); 
		for (int j = 0; j < spaces; j++) { 
			cout << " "; 
		} 

		for (int j = 0; j <= i; j++) { 
			cout << "* "; 
		} 

		cout << endl; 
	} 
} 

int main() 
{ 
	int n = 5; 

	pattern(n); 

	return 0; 
}

输出：

bash 复制代码

*                     * 
* *                 * * 
* * *             * * * 
* * * *         * * * * 
* * * * *     * * * * * 
* * * * * * * * * * * * 
* * * * *     * * * * * 
* * * *         * * * * 
* * *             * * * 
* *                 * * 
*                     *

32. 编写打印简单金字塔图案的程序

cpp 复制代码

// C++ Program to print a simple pyramid 
#include <iostream> 
using namespace std; 

int main() 
{ 
	int rows = 5; 

	for (int i = 1; i <= rows; i++) { 
		for (int j = rows; j >= i; j--) { 
			cout << " "; 
		} 
		for (int k = 1; k <= (2 * i - 1); k++) { 
			cout << "*"; 
		} 
		cout << endl; 
	} 

	return 0; 
}

输出：

bash 复制代码

     *
    ***
   *****
  *******
 *********

33. 编写程序打印倒金字塔

cpp 复制代码

// C++ Program to print inverted pyramid 
#include <iostream> 
using namespace std; 

int main() 
{ 
	int rows = 5; 

	for (int i = rows; i >= 1; i--) { 
		for (int j = rows; j > i; j--) { 
			cout << " "; 
		} 
		for (int k = 1; k <= (2 * i - 1); k++) { 
			cout << "*"; 
		} 
		cout << endl; 
	} 

	return 0; 
}

输出：

bash 复制代码

*********
 *******
  *****
   ***
    *

34. 编写程序打印三角形星形图案

cpp 复制代码

// C++ Program to print a triangle star patter 
#include <iostream> 
using namespace std; 

int main() 
{ 
	int rows; 

	rows = 5; 

	for (int i = 1; i <= rows; i++) { 
		for (int j = 1; j <= i; j++) { 
			cout << "*"; 
		} 
		cout << endl; 
	} 

	return 0; 
}

输出：

bash 复制代码

*
**
***
****
*****

35. 编写程序打印Floyd三角形

cpp 复制代码

// C Program to print the Floyd's Triangle 
#include <stdio.h> 

int main() 
{ 
	int rows = 4; 
	int n = 1; 

	// outer loop to print all rows 
	for (int i = 0; i < rows; i++) { 

		// innter loop to print abphabet in each row 
		for (int j = 0; j <= i; j++) { 
			printf("%d ", n++); 
		} 
		printf("\n"); 
	} 
	return 0; 
}

输出：

bash 复制代码

36. 编写程序打印Pascal三角形

bash 复制代码

            1   
          1   1   
        1   2   1   
      1   3   3   1   
    1   4   6   4   1   
  1   5   10   10   5   1

cpp 复制代码

// C++ program to print 
// Pascal's Triangle 
#include <iostream> 
using namespace std; 

void printPascal(int n) 
{ 

	int arr[n][n]; 

	for (int line = 0; line < n; line++) { 
		// Every line has number of integers 
		// equal to line number 
		for (int i = 0; i <= line; i++) { 
			// First and last values in every row are 1 
			if (line == i || i == 0) 
				arr[line][i] = 1; 
			else
				arr[line][i] = arr[line - 1][i - 1] 
							+ arr[line - 1][i]; 
			cout << arr[line][i] << " "; 
		} 
		cout << "\n"; 
	} 
} 

int main() 
{ 
	int n = 6; 
	printPascal(n); 
	return 0; 
}

输出：

bash 复制代码

1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1

37. 编写程序逆序打印给定字符串

cpp 复制代码

// C++ Program to reversea string 
#include <cstring> 
#include <iostream> 
using namespace std; 

int main() 
{ 

	int len; 

	string str = "GeeksforGeeks"; 

	len = str.size(); 

	cout << "Reverse of the string: "; 
	for (int i = len - 1; i >= 0; i--) { 
		cout << str[i]; 
	} 
	cout << endl; 

	return 0; 
}

输出：

bash 复制代码

Reverse of the string: skeeGrofskeeG

38. 编写C++程序，使用递归逆序打印给定字符串

cpp 复制代码

// C++ Program to 
// Reverse string using 
// recursion 
#include <iostream> 
using namespace std; 

void reverse_str(string& s, int n, int i) 
{ 
	if (n <= i) { 
		return; 
	} 

	swap(s[i], s[n]); 
	reverse_str(s, n - 1, i + 1); 
} 

int main() 
{ 
	string str = "GeeksforGeeks"; 
	reverse_str(str, str.length() - 1, 0); 
	cout << str << endl; 
}

输出：

bash 复制代码

skeeGrofskeeG

39. 编写程序，使用递归判断给定的字符串是否为回文

cpp 复制代码

// C++ program to check 
// Whether a given number 
// Is palindrome or not 
#include <bits/stdc++.h> 
using namespace std; 

bool isPalRec(char str[], int s, int n) 
{ 
	// If there is only one character 
	if (s == n) 
		return true; 

	// If first and last 
	// characters do not match 
	if (str[s] != str[n]) 
		return false; 

	if (s < n + 1) 
		return isPalRec(str, s + 1, n - 1); 

	return true; 
} 

bool isPalindrome(char str[]) 
{ 
	int n = strlen(str); 

	if (n == 0) 
		return true; 

	return isPalRec(str, 0, n - 1); 
} 

int main() 
{ 
	char str[] = "GeeKeeG"; 

	if (isPalindrome(str)) 
		cout << "Yes"; 
	else
		cout << "No"; 

	return 0; 
}

输出：

bash 复制代码

Yes

40. 使用递归计算字符串长度

cpp 复制代码

// C++ Program for calculating 
// the length of string 
#include <iostream> 
using namespace std; 

int cal(char* str) 
{ 
	// base condition 
	if (*str == '\0') 
		return 0; 
	else
		return 1 + cal(str + 1); 
} 

int main() 
{ 
	char str[] = "GeeksforGeeks"; 
	cout << cal(str); 
	return 0; 
}

输出：

bash 复制代码

41. 使用递归计算一个数的阶乘

cpp 复制代码

// C++ program to calculate 
// Factorial of given number 
#include <iostream> 
using namespace std; 

unsigned long long factorial(unsigned long long n) 
{ 
	if (n == 0 || n == 1) 
		return 1; 
	return n * factorial(n - 1); 
} 

int main() 
{ 
	unsigned long long num = 15; 

	cout << "Factorial of " << num << " is "
		<< factorial(num) << endl; 

	return 0; 
}

输出：

bash 复制代码

Factorial of 15 is 1307674368000

42. 编写程序计算字符串中数字的总和

cpp 复制代码

// C++ Program to count the sume of numbers in a string 
#include <iostream> 
#include <sstream> 
#include <string> 

using namespace std; 

int sum_of_numbers(string str) 
{ 
	int sum = 0; 
	for (char ch : str) { 
		if (isdigit(ch)) { 
			sum += ch - '0'; 
		} 
	} 
	return sum; 
} 

int main() 
{ 
	string str; 

	str = "1234"; 

	cout << "Sum of numbers: " << sum_of_numbers(str) 
		<< endl; 

	return 0; 
}

输出：

bash 复制代码

Sum of numbers: 10

43. 编写一个程序，在不使用分号的情况下打印N以内的所有自然数

cpp 复制代码

// C++ program to print all natural numbers upto 
// N without using semi-colon 
#include <iostream> 

using namespace std; 
#define N 10 

int main() 
{ 
	static int x = 1; 
	if (cout << x << " " && x++ < N && main()) { 
	} 
	return 0; 
}

输出：

bash 复制代码

1 2 3 4 5 6 7 8 9 10

44. 编写一个程序，在不使用任何额外变量的情况下交换两个变量的值

cpp 复制代码

// C++ program to check 
// If two numbers are equal 
#include <iostream> 
using namespace std; 

int main() 
{ 
	int x = 3; 
	int y = 4; 

	cout << "X : " << x << endl; 
	cout << "Y : " << y << endl; 

	x = x + y; 
	y = x - y; 
	x = x - y; 

	cout << endl; 
	cout << "After:" << endl; 

	cout << "X : " << x << endl; 
	cout << "Y : " << y << endl; 

	return 0; 
}

输出：

bash 复制代码

X : 3
Y : 4

After:
X : 4
Y : 3

45. 编写程序，使用补码(~)运算符打印无符号整数类型的最大值

cpp 复制代码

// C++ program to print maximum value of 
// unsigned int. 
#include <iostream> 

using namespace std; 

int main() 
{ 
	unsigned int max; 
	max = 0; 
	max = ~max; 

	cout << "Max value possible : " << max; 

	return 0; 
}

输出：

bash 复制代码

Max value possible : 4294967295

46. 不使用算术或比较运算符，检查两个数字的相等性

cpp 复制代码

// C++ Program to equality of 
// Two numbers without using 
// Arithmetic or comparison operator 
#include <iostream> 
using namespace std; 

int main() 
{ 
	int a = 10, b = 10; 

	if (a ^ b) 
		cout << "Not-Equal"; 
	else
		cout << "Equal"; 

	return 0; 
}

输出

bash 复制代码

Equal

47. 编写一个程序，在不使用比较运算符的情况下求两个数的最大值和最小值

cpp 复制代码

// C++ program to find 
// maximum and minimum of 
// Two numbers without using 
// loop and conditions 
#include <iostream> 

using namespace std; 

int main() 
{ 
	int a = 5, b = 10; 

	cout << "max :" << (((a + b) + abs(a - b)) / 2) << endl; 
	cout << "min :" << (((a + b) - abs(a - b)) / 2) << endl; 

	return 0; 
}

输出：

bash 复制代码

max :10
min :5

48. 编写八进制到十进制转换程序

cpp 复制代码

// C++ Program to convert ocatal to decimal 
#include <cmath> 
#include <iostream> 

using namespace std; 

int main() 
{ 
	int oct, dec = 0, place = 0; 
	// 67 is an octal number with binary equivalent 110000 
	oct = 67; 

	int temp = oct; 
	while (temp) { 
		int lastDigit = temp % 10; 
		temp /= 10; 
		dec += lastDigit * pow(8, place); 
		++place; 
	} 

	cout << "Decimal equivalent is: " << dec << endl; 

	return 0; 
}

输出：

bash 复制代码

Decimal equivalent is: 55

49. 编写十六进制到十进制转换的程序

cpp 复制代码

// C++ Program to convert hexadecimal to decimal conversion 
#include <cmath> 
#include <iostream> 

using namespace std; 

int hexToDecimal(char hexDigit) 
{ 
	if (hexDigit >= '0' && hexDigit <= '9') { 
		return int(hexDigit - '0'); 
	} 
	else if (hexDigit >= 'A' && hexDigit <= 'F') { 
		return int(hexDigit - 'A' + 10); 
	} 
	else if (hexDigit >= 'a' && hexDigit <= 'f') { 
		return int(hexDigit - 'a' + 10); 
	} 
	return -1; 
} 

int main() 
{ 
	string hex; 
	int decimal = 0, place = 0; 

	hex = "67"; 

	int n = hex.length(); 
	for (int i = n - 1; i >= 0; i--) { 
		int digit = hexToDecimal(hex[i]); 
		decimal += digit * pow(16, place); 
		place++; 
	} 

	cout << "Decimal equivalent " << decimal << endl; 

	return 0; 
}

输出：

bash 复制代码

Decimal equivalent 103

50. 编写一个十进制到二进制转换的程序

cpp 复制代码

// c++ program to convert decimal to binary 
#include <bitset> 
#include <iostream> 

using namespace std; 

int main() 
{ 
	int decimal = 7; 

	// simplest method to convert decimal to binary 
	bitset<32> binary(decimal); 

	cout << "Binary equivalent: " << binary << endl; 

	return 0; 
}

输出：

bash 复制代码

Binary equivalent: 00000000000000000000000000000111

51. 编写一个程序进行十进制八进制转换

cpp 复制代码

// C++ Program to convert decimal to octal equivalent 
#include <cmath> 
#include <iostream> 

using namespace std; 

int main() 
{ 
	int decimal, octal = 0, place = 1; 

	decimal = 55; 

	int temp = decimal; 
	while (temp) { 
		int lastDigit = temp % 8; 
		temp /= 8; 
		octal += lastDigit * place; 
		place *= 10; 
	} 

	cout << "Octal equivalent " << octal << endl; 

	return 0; 
}

输出

bash 复制代码

Octal equivalent 67

52. 编写十进制到十六进制转换程序

cpp 复制代码

// C++ program to convert decimal to hexadecimal 
#include <cmath> 
#include <iostream> 
#include <string> 

using namespace std; 

string decimalToHexa(int decimal) 
{ 
	string hexadecimal = ""; 
	char hexaDecimals[16] 
		= { '0', '1', '2', '3', '4', '5', '6', '7', 
			'8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; 
	while (decimal > 0) { 
		int remainder = decimal % 16; 
		hexadecimal = hexaDecimals[remainder] + hexadecimal; 
		decimal /= 16; 
	} 
	return hexadecimal; 
} 

int main() 
{ 
	int decimal = 103; 

	cout << "Hexadecimal equivalent: "
		<< decimalToHexa(decimal) << endl; 

	return 0; 
}

输出：

bash 复制代码

Hexadecimal equivalent: 67

53. 编写二进制到八进制转换程序

cpp 复制代码

// C++ implementation to convert a binary number 
// to octal number 
#include <bits/stdc++.h> 
using namespace std; 

// function to create map between binary 
// number and its equivalent octal 
void createMap(unordered_map<string, char>* um) 
{ 
	(*um)["000"] = '0'; 
	(*um)["001"] = '1'; 
	(*um)["010"] = '2'; 
	(*um)["011"] = '3'; 
	(*um)["100"] = '4'; 
	(*um)["101"] = '5'; 
	(*um)["110"] = '6'; 
	(*um)["111"] = '7'; 
} 

// Function to find octal equivalent of binary 
string convertBinToOct(string bin) 
{ 
	int l = bin.size(); 
	int t = bin.find_first_of('.'); 

	// length of string before '.' 
	int len_left = t != -1 ? t : l; 

	// add min 0's in the beginning to make 
	// left substring length divisible by 3 
	for (int i = 1; i <= (3 - len_left % 3) % 3; i++) 
		bin = '0' + bin; 

	// if decimal point exists 
	if (t != -1) { 
		// length of string after '.' 
		int len_right = l - len_left - 1; 

		// add min 0's in the end to make right 
		// substring length divisible by 3 
		for (int i = 1; i <= (3 - len_right % 3) % 3; i++) 
			bin = bin + '0'; 
	} 

	// create map between binary and its 
	// equivalent octal code 
	unordered_map<string, char> bin_oct_map; 
	createMap(&bin_oct_map); 

	int i = 0; 
	string octal = ""; 

	while (1) { 
		// one by one extract from left, substring 
		// of size 3 and add its octal code 
		octal += bin_oct_map[bin.substr(i, 3)]; 
		i += 3; 
		if (i == bin.size()) 
			break; 

		// if '.' is encountered add it to result 
		if (bin.at(i) == '.') { 
			octal += '.'; 
			i++; 
		} 
	} 

	// required octal number 
	return octal; 
} 

// Driver program to test above 
int main() 
{ 
	string bin = "1111001010010100001.010110110011011"; 
	cout << "Octal number = " << convertBinToOct(bin); 
	return 0; 
}

输出：

bash 复制代码

Octal number = 1712241.26633

54. 编写八进制到二进制转换的程序

cpp 复制代码

// C++ program to convert 
// Octal number to Binary 

#include <iostream> 
using namespace std; 

// Function to convert an 
// Octal to Binary Number 
string OctToBin(string octnum) 
{ 
	long int i = 0; 

	string binary = ""; 

	while (octnum[i]) { 
		switch (octnum[i]) { 
		case '0': 
			binary += "000"; 
			break; 
		case '1': 
			binary += "001"; 
			break; 
		case '2': 
			binary += "010"; 
			break; 
		case '3': 
			binary += "011"; 
			break; 
		case '4': 
			binary += "100"; 
			break; 
		case '5': 
			binary += "101"; 
			break; 
		case '6': 
			binary += "110"; 
			break; 
		case '7': 
			binary += "111"; 
			break; 
		default: 
			cout << "\nInvalid Octal Digit " << octnum[i]; 
			break; 
		} 
		i++; 
	} 

	return binary; 
} 

// Driver code 
int main() 
{ 
	// Get the Hexadecimal number 
	string octnum = "345"; 

	// Convert Octal to Binary 
	cout << "Equivalent Binary Value = "
		<< OctToBin(octnum); 

	return 0; 
}

输出：

bash 复制代码

Equivalent Binary Value = 011100101

55. 编写一个程序来实现封装的使用

cpp 复制代码

// C++ Program to implement 
// The concept of Encapsulation 
#include <iostream> 
using namespace std; 

class Encapsulation { 
private: 
	// data hidden from outer functions 
	int x; 

public: 
	// function to set value of 
	// variable x 
	void setter(int a) { x = a; } 

	// function to return value of 
	// variable x 
	int getter() { return x; } 
}; 

int main() 
{ 
	Encapsulation obj; 

	obj.setter(13); 

	cout << obj.getter(); 

	return 0; 
}

输出：

bash 复制代码

56. 编写一个实现抽象概念的程序

cpp 复制代码

// C++ Program to implement 
// Working of Abstraction 
#include <iostream> 
using namespace std; 

class implementAbstraction { 
private: 
	int p, q; 

public: 
	// method to set values of 
	// private members 
	void setter(int x, int y) 
	{ 
		p = x; 
		q = y; 
	} 

	void display() 
	{ 
		cout << "p = " << p << endl; 
		cout << "q = " << q << endl; 
	} 
}; 

int main() 
{ 
	implementAbstraction obj; 

	obj.setter(1, 2); 
	obj.display(); 

	return 0; 
}

输出：

bash 复制代码

p = 1
q = 2

57. 编写程序实现编译时多态性或函数重载的概念

cpp 复制代码

// C++ program to demonstrate 
// Function overloading or 
// Compile-time Polymorphism 
#include <iostream> 

using namespace std; 

class Geeks { 
public: 
	// Function same name different 
	// Parameters 
	void func(int x) 
	{ 
		cout << "value of x is " << x << endl; 
	} 

	void func(double x) 
	{ 
		cout << "value of x is " << x << endl; 
	} 

	void func(int x, int y) 
	{ 
		cout << "value of x and y is " << x << ", " << y 
			<< endl; 
	} 
}; 

int main() 
{ 
	Geeks obj1; 

	// Function being called depends 
	// on the parameters passed 
	// func() is called with int value 
	obj1.func(10); 

	// func() is called with double value 
	obj1.func(5.321); 

	// func() is called with 2 int values 
	obj1.func(94, 32); 
	return 0; 
}

输出

bash 复制代码

value of x is 10
value of x is 5.321
value of x and y is 94, 32

58. 编写一个实现运算符重载概念的程序

cpp 复制代码

// C++ program to demonstrate 
// Operator Overloading 
#include <iostream> 
using namespace std; 

class Complex { 
private: 
	int real, imag; 

public: 
	Complex(int r = 0, int i = 0) 
	{ 
		real = r; 
		imag = i; 
	} 

	// This is automatically called 
	// when '+' is used 
	Complex operator+(Complex const& obj) 
	{ 
		Complex res; 
		res.real = real + obj.real; 
		res.imag = imag + obj.imag; 
		return res; 
	} 
	void print() { cout << real << " + " << imag << "i\n"; } 
}; 

int main() 
{ 
	Complex c1(15, 5), c2(3, 5); 

	Complex c3 = c1 + c2; 
	c3.print(); 
}

输出：

bash 复制代码

18 + 10i

59. 编写一个程序来实现函数重写或运行时多态性的概念

cpp 复制代码

// C++ program for implementation 
// of Function Overloading or 
// Compile time Polymorphism 
#include <iostream> 
using namespace std; 

class base { 
public: 
	virtual void print() 
	{ 
		cout << "print base class" << endl; 
	} 

	void show() { cout << "show base class" << endl; } 
}; 

class derived : public base { 
public: 
	void print() { cout << "print derived class" << endl; } 

	void show() { cout << "show derived class" << endl; } 
}; 

int main() 
{ 
	base* bptr; 
	derived d; 
	bptr = &d; 

	bptr->print(); 

	// Non-virtual function, binded 
	// at compile time 
	bptr->show(); 

	return 0; 
}

输出：

bash 复制代码

print derived class
show base class

60. 编写实现单继承的程序

cpp 复制代码

// C++ Program to implement 
// Single level inheritance 
#include <iostream> 
#include <string.h> 

using namespace std; 

class Person { 
	int id; 
	char name[100]; 

public: 
	void set_p(int id, char* name) 
	{ 
		strcpy(this->name, name); 
		this->id = id; 
	} 

	void display_p() 
	{ 
		cout << endl << id << "\t" << name << "\t"; 
	} 
}; 

class Student : private Person { 
	char course[50]; 
	int fee; 

public: 
	void set_s(int id, char* name, char* course, int fee) 
	{ 
		set_p(id, name); 

		strcpy(this->course, course); 

		this->fee = fee; 
	} 

	void display_s() 
	{ 
		display_p(); 

		cout << course << "\t" << fee << endl; 
	} 
}; 

main() 
{ 
	Student s; 
	char name[] = "XYZ"; 
	char course[] = "ABC"; 
	s.set_s(132451, name, course, 100000); 
	s.display_s(); 
	return 0; 
}

输出

bash 复制代码

132451    XYZ    ABC    100000

61. 编写程序创建一个复数类

cpp 复制代码

// C++ Program to create a class of complex numbers 
#include <bits/stdc++.h> 
using namespace std; 

// complex number datatype 
struct c { 
	double real; 
	double img; 
}; 

// complex clss 
class Complex { 
private: 
	struct c num; 

public: 
	// constructors 
	Complex() {} 
	Complex(double real, double img) 
	{ 
		num.img = img; 
		num.real = real; 
	} 
	Complex(Complex& var) 
	{ 
		num.img = var.num.img; 
		num.real = var.num.real; 
	} 

	// utility functions 
	void print() 
	{ 
		cout << num.real << " + i" << num.img << endl; 
	} 

	double imag() { return num.img; } 
	double real() { return num.real; } 

	// overloaded operators 
	Complex operator+(Complex& obj1) 
	{ 
		Complex var; 
		var.num.real = num.real + obj1.num.real; 
		var.num.img = num.img + obj1.num.img; 

		return var; 
	} 
	Complex operator-(Complex& obj1) 
	{ 
		Complex var; 
		var.num.real = num.real - obj1.num.real; 
		var.num.img = num.img - obj1.num.img; 

		return var; 
	} 

	Complex operator*(Complex& obj1) 
	{ 
		Complex var; 
		var.num.real = num.real * obj1.num.real 
					- num.img * obj1.num.img; 
		var.num.img = num.real * obj1.num.img 
					+ num.img * obj1.num.real; 

		return var; 
	} 
}; 

// driver code 
int main() 
{ 
	Complex a(11, 12), b(5, 8); 
	Complex c; 
	c = a + b; 

	a.print(); 
	b.print(); 
	c.print(); 

	return 0; 
}

输出

bash 复制代码

11 + i12
5 + i8
16 + i20

62. 编写一个程序来实现英寸-英尺系统

cpp 复制代码

// C++ Program to create a class of inchFeet length system 
#include <bits/stdc++.h> 
using namespace std; 

// inch-feet length system datatype 
struct c { 
	double feet; 
	double inch; 
}; 

// inchFeet class 
class inchFeet { 
private: 
	struct c length; 

public: 
	// constructors 
	inchFeet() {} 
	inchFeet(double feet, double inch) 
	{ 
		length.inch = inch; 
		length.feet = feet; 
	} 
	inchFeet(inchFeet& var) 
	{ 
		length.inch = var.length.inch; 
		length.feet = var.length.feet; 
	} 

	// utility functions 
	void print() 
	{ 
		cout << length.feet << " feet and " << length.inch 
			<< " inches" << endl; 
	} 

	double inches() { return length.inch; } 
	double feet() { return length.feet; } 

	// overloaded operators 
	inchFeet operator+(inchFeet& obj1) 
	{ 
		inchFeet var; 
		var.length.feet = length.feet + obj1.length.feet; 
		var.length.inch = length.inch + obj1.length.inch; 
		if (var.length.inch >= 12.0) { 
			var.length.feet++; 
			var.length.inch - 12.0; 
		} 

		return var; 
	} 
	inchFeet operator-(inchFeet& obj1) 
	{ 
		inchFeet var; 
		struct c temp = length; 
		if (temp.feet > obj1.length.feet) { 
			if (temp.inch < obj1.length.inch) { 
				temp.feet--; 
				temp.inch += 12; 
			} 
			var.length.feet = temp.feet - obj1.length.feet; 
			var.length.inch = temp.inch - obj1.length.inch; 
		} 
		else { 
			cout << "Negative Length is not Possible\n"; 
		} 
		return var; 
	} 
}; 

// driver code 
int main() 
{ 
	inchFeet a(11, 4), b(5, 8); 
	inchFeet c; 
	c = a - b; 

	a.print(); 
	b.print(); 
	c.print(); 

	return 0; 
}

输出

bash 复制代码

11 feet and 4 inches
5 feet and 8 inches
5 feet and 8 inches

63. 编写程序实现冒泡排序

cpp 复制代码

// C++ program to implement 
// of Bubble sort 
#include <iostream> 
using namespace std; 

// Function to sort 
void bubbleSort(int arr[], int n) 
{ 
	int i, j; 
	for (i = 0; i < n - 1; i++) 
		// Last i elements are already in place 
		for (j = 0; j < n - i - 1; j++) 
			if (arr[j] > arr[j + 1]) 
				swap(arr[j], arr[j + 1]); 
} 

// Function to print an array 
void printArray(int arr[], int size) 
{ 
	int i; 
	for (i = 0; i < size; i++) 
		cout << arr[i] << " "; 
	cout << endl; 
} 

int main() 
{ 
	int arr[] = { 3, 1, 4, 2, 5 }; 
	int N = sizeof(arr) / sizeof(arr[0]); 

	bubbleSort(arr, N); 

	cout << "Sorted array: "; 
	printArray(arr, N); 
	return 0; 
}

输出

bash 复制代码

Sorted array: 1 2 3 4 5

64. 编写程序实现插入排序

cpp 复制代码

// C++ program to implement 
// Insertion sort 
#include <bits/stdc++.h> 
using namespace std; 

// Function to sort using 
// Insertion 
void insertion_sort(int arr[], int n) 
{ 
	int i, key, j; 
	for (i = 1; i < n; i++) { 
		key = arr[i]; 
		j = i - 1; 

		while (j >= 0 && arr[j] > key) { 
			arr[j + 1] = arr[j]; 
			j = j - 1; 
		} 
		arr[j + 1] = key; 
	} 
} 

// Print array 
void print_array(int arr[], int n) 
{ 
	cout << " Sorted array:"; 
	for (int i = 0; i < n; i++) 
		cout << arr[i] << " "; 
	cout << endl; 
} 

int main() 
{ 
	int arr[] = { 1, 4, 3, 2, 5 }; 
	int N = sizeof(arr) / sizeof(arr[0]); 

	insertion_sort(arr, N); 
	print_array(arr, N); 

	return 0; 
}

输出

bash 复制代码

Sorted array:1 2 3 4 5

65. 编写程序以实现选择排序

cpp 复制代码

// C++ program to implement 
// Selection sort 
#include <iostream> 
using namespace std; 

// Swap function 
void swap(int* p, int* q) 
{ 
	int temp = *p; 
	*p = *q; 
	*q = temp; 
} 

void selectionSort(int arr[], int n) 
{ 
	int min_index; 

	for (int i = 0; i < n - 1; i++) { 
		min_index = i; 
		for (int j = i + 1; j < n; j++) 
			if (arr[j] < arr[min_index]) 
				min_index = j; 

		// Swap the found minimum element 
		// with the first element 
		if (min_index != i) 
			swap(&arr[min_index], &arr[i]); 
	} 
} 

// Print Array 
void printArray(int arr[], int size) 
{ 
	int i; 
	for (i = 0; i < size; i++) 
		cout << arr[i] << " "; 
	cout << endl; 
} 

int main() 
{ 
	int arr[] = { 5, 4, 3, 2, 1 }; 
	int n = sizeof(arr) / sizeof(arr[0]); 

	selectionSort(arr, n); 

	cout << "Sorted array: "; 
	printArray(arr, n); 

	return 0; 
}

输出

bash 复制代码

Sorted array: 1 2 3 4 5

66. 编写程序实现归并排序

cpp 复制代码

// C++ program to implement 
// Merge Sort 
#include <iostream> 
using namespace std; 

// Merge Sorted arrays 
void merge(int array[], int const left, int const mid, 
		int const right) 
{ 
	auto const subArrayOne = mid - left + 1; 
	auto const subArrayTwo = right - mid; 

	// Create temp arrays 
	auto *leftArray = new int[subArrayOne], 
		*rightArray = new int[subArrayTwo]; 

	// Copy data to temp arrays leftArray[] and rightArray[] 
	for (auto i = 0; i < subArrayOne; i++) 
		leftArray[i] = array[left + i]; 
	for (auto j = 0; j < subArrayTwo; j++) 
		rightArray[j] = array[mid + 1 + j]; 

	auto indexOfSubArrayOne = 0, indexOfSubArrayTwo = 0; 
	int indexOfMergedArray = left; 

	// Merge the temp arrays back into array[left..right] 
	while (indexOfSubArrayOne < subArrayOne 
		&& indexOfSubArrayTwo < subArrayTwo) { 
		if (leftArray[indexOfSubArrayOne] 
			<= rightArray[indexOfSubArrayTwo]) { 
			array[indexOfMergedArray] 
				= leftArray[indexOfSubArrayOne]; 
			indexOfSubArrayOne++; 
		} 
		else { 
			array[indexOfMergedArray] 
				= rightArray[indexOfSubArrayTwo]; 
			indexOfSubArrayTwo++; 
		} 
		indexOfMergedArray++; 
	} 

	// Copying remaing elements 
	while (indexOfSubArrayOne < subArrayOne) { 
		array[indexOfMergedArray] 
			= leftArray[indexOfSubArrayOne]; 
		indexOfSubArrayOne++; 
		indexOfMergedArray++; 
	} 

	while (indexOfSubArrayTwo < subArrayTwo) { 
		array[indexOfMergedArray] 
			= rightArray[indexOfSubArrayTwo]; 
		indexOfSubArrayTwo++; 
		indexOfMergedArray++; 
	} 
	delete[] leftArray; 
	delete[] rightArray; 
} 

void mergeSort(int array[], int const begin, int const end) 
{ 
	// base condition 
	if (begin >= end) 
		return; 

	auto mid = begin + (end - begin) / 2; 
	mergeSort(array, begin, mid); 
	mergeSort(array, mid + 1, end); 
	merge(array, begin, mid, end); 
} 

// Print Array 
void print_array(int A[], int size) 
{ 
	for (auto i = 0; i < size; i++) 
		cout << A[i] << " "; 
} 

int main() 
{ 
	int arr[] = { 5, 6, 3, 10, 1, 4, 9 }; 
	auto arr_size = sizeof(arr) / sizeof(arr[0]); 

	cout << "Array: "; 
	print_array(arr, arr_size); 

	mergeSort(arr, 0, arr_size - 1); 

	cout << "\nSorted array: "; 
	print_array(arr, arr_size); 
	return 0; 
}

输出：

bash 复制代码

Array: 5 6 3 10 1 4 9 
Sorted array: 1 3 4 5 6 9 10

67. 编写程序实现快速排序

cpp 复制代码

// C++ Program to implement 
// QuickSort 
#include <iostream> 
using namespace std; 

// Swap elements 
void swap(int* a, int* b) 
{ 
	int t = *a; 
	*a = *b; 
	*b = t; 
} 

// Partition function to check pivot location 
int partition(int arr[], int low, int high) 
{ 
	int pivot = arr[high]; // pivot 
	int i = (low - 1); 

	for (int j = low; j <= high - 1; j++) { 
		// If current element is smaller than the pivot 
		if (arr[j] < pivot) { 
			i++; 
			swap(&arr[i], &arr[j]); 
		} 
	} 
	swap(&arr[i + 1], &arr[high]); 
	return (i + 1); 
} 

// Quick Sort function 
void quickSort(int arr[], int low, int high) 
{ 
	if (low < high) { 
		// pi is partitioning index, arr[p] is now 
		// at right place 
		int pi = partition(arr, low, high); 

		// Separately sort elements before 
		// partition and after partition 
		quickSort(arr, low, pi - 1); 
		quickSort(arr, pi + 1, high); 
	} 
} 

// Print Array 
void printArray(int arr[], int size) 
{ 
	int i; 
	for (i = 0; i < size; i++) 
		cout << arr[i] << " "; 
	cout << endl; 
} 

int main() 
{ 
	int arr[] = { 2, 5, 6, 9, 1, 3, 4 }; 
	int n = sizeof(arr) / sizeof(arr[0]); 

	cout << "Array: "; 
	printArray(arr, n); 

	quickSort(arr, 0, n - 1); 

	cout << "Sorted array: "; 
	printArray(arr, n); 
	return 0; 
}

输出

bash 复制代码

Array: 2 5 6 9 1 3 4 
Sorted array: 1 2 3 4 5 6 9

68. 编写程序实现线性搜索

cpp 复制代码

// C++ Program to implement 
// Linear Sort 
#include <iostream> 
using namespace std; 

int search(int arr[], int N, int x) 
{ 
	int i; 
	for (i = 0; i < N; i++) 
		if (arr[i] == x) 
			return i; 
	return -1; 
} 

int main() 
{ 
	int arr[] = { 5, 4, 1, 6, 10, 9, 23, 2 }; 
	int x = 9; 
	int N = sizeof(arr) / sizeof(arr[0]); 

	int result = search(arr, N, x); 

	if (result == -1) 
		cout << "Element is not present in array"; 
	else
		cout << "Element is present at index " << result; 
	return 0; 
}

输出：

bash 复制代码

Element is present at index 5

69. 编写一个程序实现二分查找

cpp 复制代码

// C++ program to implement 
// Binary Search 
#include <iostream> 
using namespace std; 

// Binary Search Function 
int binarySearch(int arr[], int l, int r, int x) 
{ 
	if (r >= l) { 
		// Middle element 
		int mid = l + (r - l) / 2; 

		if (arr[mid] == x) 
			return mid; 

		if (arr[mid] > x) 
			return binarySearch(arr, l, mid - 1, x); 

		return binarySearch(arr, mid + 1, r, x); 
	} 

	// We reach here when element is not 
	// present in array 
	return -1; 
} 

int main(void) 
{ 
	int arr[] = { 1, 2, 3, 4, 5, 6 }; 
	int x = 5; 
	int n = sizeof(arr) / sizeof(arr[0]); 

	int result = binarySearch(arr, 0, n - 1, x); 

	if (result == -1) 
		cout << "Element is not present in array"; 
	else
		cout << "Element is present at index " << result; 
	return 0; 
}

输出：

bash 复制代码

Element is present at index 4

70. 编写一个程序来查找vector中给定元素的下标

cpp 复制代码

// C++ program to find the index 
// of an element in a vector 
#include <bits/stdc++.h> 

using namespace std; 

// print index of element 
void print_index(vector<int> v, int element) 
{ 
	auto it = find(v.begin(), v.end(), element); 

	// Condition if element found 
	if (it != v.end()) { 

		// Calculating the index 
		// of element 
		int index = it - v.begin(); 
		cout << index << endl; 
	} 
	// No such element in vector 
	else { 
		cout << "-1" << endl; 
	} 
} 

int main() 
{ 
	vector<int> v = { 1, 2, 3, 4, 5, 6 }; 

	int element = 5; 
	print_index(v, element); 

	return 0; 
}

输出

bash 复制代码

Output

71. 编写程序，使用STL删除数组中重复的元素

cpp 复制代码

// C++ program to remove the 
// duplicate elements from the array 
// using STL in C++ 
#include <bits/stdc++.h> 

using namespace std; 

// Function to remove duplicate elements 
void removeDuplicates(int arr[], int n) 
{ 

	int i; 

	set<int> s; 

	// Insert the array elements 
	// into the set 
	for (i = 0; i < n; i++) { 
		s.insert(arr[i]); 
	} 

	set<int>::iterator it; 

	// Print the array with duplicates removed 
	cout << "\nAfter removing duplicates:\n"; 
	for (it = s.begin(); it != s.end(); ++it) 
		cout << *it << " "; 
	cout << '\n'; 
} 

int main() 
{ 
	int arr[] = { 1, 2, 2, 4, 3, 3, 2, 1 }; 

	int n = sizeof(arr) / sizeof(arr[0]); 

	// Print array 
	cout << "\nBefore removing duplicates:\n"; 
	for (int i = 0; i < n; i++) 
		cout << arr[i] << " "; 

	removeDuplicates(arr, n); 

	return 0; 
}

输出

bash 复制代码

Before removing duplicates:
1 2 2 4 3 3 2 1 
After removing duplicates:
1 2 3 4

72. 用STL编写数组降序排序程序

cpp 复制代码

// C++ program to sort Array 
// in descending order 
#include <bits/stdc++.h> 
using namespace std; 

int main() 
{ 
	// Get the array 
	int arr[] = { 1, 2, 3, 4, 5, 6 }; 

	// Compute the sizes 
	int n = sizeof(arr) / sizeof(arr[0]); 

	// Print the array 
	cout << "Array: "; 
	for (int i = 0; i < n; i++) 
		cout << arr[i] << " "; 

	// Sort the array in descending order 
	sort(arr, arr + n, greater<int>()); 

	// Print the array 
	cout << "\nDescending Sorted Array:"; 
	for (int i = 0; i < n; i++) 
		cout << arr[i] << " "; 

	return 0; 
}

输出

bash 复制代码

Array: 1 2 3 4 5 6 
Descending Sorted Array:6 5 4 3 2 1

73. 编写程序计算给定字符串中每个单词的频率

cpp 复制代码

// C++ program to calculate 
// frequency of each word 
// in given string 
#include <bits/stdc++.h> 
using namespace std; 

// Function to print frequency of each word 
void printFrequency(string str) 
{ 
	map<string, int> M; 

	string word = ""; 

	for (int i = 0; i < str.size(); i++) { 

		// if element is empty 
		if (str[i] == ' ') { 

			// If the current word 
			// is not found then insert 
			// current word with frequency 1 
			if (M.find(word) == M.end()) { 
				M.insert(make_pair(word, 1)); 
				word = ""; 
			} 
			else { 
				M[word]++; 
				word = ""; 
			} 
		} 

		else
			word += str[i]; 
	} 

	// Storing the last word of the string 
	if (M.find(word) == M.end()) 
		M.insert(make_pair(word, 1)); 

	// Update the frequency 
	else
		M[word]++; 

	// Traverse the map 
	for (auto& it : M) { 
		cout << it.first << " - " << it.second << endl; 
	} 
} 

int main() 
{ 
	string str = "Geeks For Geeks is for Geeks"; 

	printFrequency(str); 
	return 0; 
}

输出

bash 复制代码

For - 1
Geeks - 3
for - 1
is - 1

74. 编写一个程序，按原始顺序查找数组最大的 k 个元素

cpp 复制代码

// C++ program to find k Maximum elements 
#include <bits/stdc++.h> 
using namespace std; 

// Function to print k Maximum elements 
void printMax(int arr[], int n, int k) 
{ 
	int result[n], c[n]; 

	// Coping the array a 
	// into c and initialising 
	for (int i = 0; i < n; i++) { 
		c[i] = arr[i]; 
		result[i] = 0; 
	} 

	for (int i = 0; i < k; i++) { 

		int maxi = INT_MIN; 
		int index; 
		for (int j = 0; j < n; j++) { 
			if (arr[j] > maxi) { 
				maxi = arr[j]; 
				index = j; 
			} 
		} 
		// Assigning 1 in order 
		// to mark the position 
		// of all k maximum numbers 
		result[index] = 1; 
		arr[index] = INT_MIN; 
	} 

	// Printing elements 
	for (int i = 0; i < n; i++) { 
		if (result[i] == 1) 
			cout << c[i] << " "; 
	} 
} 

int main() 
{ 
	int arr[] = { 50, 8, 45, 12, 25, 40, 84 }; 
	int n = sizeof(arr) / sizeof(arr[0]); 
	int k = 3; 
	printMax(arr, n, k); 
	return 0; 
}

输出

bash 复制代码

50 45 84

75. 编写一个程序，使用STL找出给定集合的所有不同子集

cpp 复制代码

// C++ code for the above approach: 

#include <bits/stdc++.h> 
using namespace std; 

void solve(vector<int>& arr, int n, set<vector<int> >& ans, 
		vector<int> v, int i) 
{ 
	// Base Condition 
	if (i >= n) { 
		ans.insert(v); 
		return; 
	} 

	solve(arr, n, ans, v, i + 1); 

	v.push_back(arr[i]); 
	solve(arr, n, ans, v, i + 1); 
} 

vector<vector<int> > AllSubsets(vector<int> arr, int n) 
{ 

	// Set of vectors to store 
	// required unique subsets 
	set<vector<int> > ans; 

	sort(arr.begin(), arr.end()); 
	vector<int> v; 
	solve(arr, n, ans, v, 0); 

	// Vector of vectors to store final result 
	vector<vector<int> > res; 
	while (!ans.empty()) { 
		res.push_back(*ans.begin()); 
		ans.erase(ans.begin()); 
	} 
	return res; 
} 

// Print Function 
void print(int N, vector<int>& A) 
{ 
	vector<vector<int> > result = AllSubsets(A, N); 

	// printing the output 
	for (int i = 0; i < result.size(); i++) { 
		cout << '('; 
		for (int j = 0; j < result[i].size(); j++) { 
			cout << result[i][j]; 
			if (j < result[i].size() - 1) 
				cout << " "; 
		} 
		cout << "), "; 
	} 
	cout << "\n"; 
} 

int main() 
{ 
	int N = 3; 
	vector<int> A = { 1, 2, 3 }; 

	print(N, A); 
	return 0; 
}

输出

bash 复制代码

(), (1), (1 2), (1 2 3), (1 3), (2), (2 3), (3),

76. 编写一个程序遍历一个队列，但不删除其中的元素

cpp 复制代码

// C++ program to iterate a 
// STL Queue by Creating 
// copy of given queue 
#include <iostream> 
#include <queue> 
using namespace std; 
int main() 
{ 
	queue<int> q; 

	// Inserting elements in queue 
	q.push(1); 
	q.push(2); 
	q.push(3); 
	q.push(4); 
	q.push(5); 

	// Copy queue 
	queue<int> copy_queue = q; 

	cout << "Queue elements :\n"; 

	while (!copy_queue.empty()) { 
		cout << copy_queue.front() << " "; 

		copy_queue.pop(); 
	} 

	return 0; 
}

输出

bash 复制代码

Queue elements :
1 2 3 4 5

77. 编写一个程序，使用数组实现栈

cpp 复制代码

// C++ Program to implement stacks using array 
#include <iostream> 
using namespace std; 

// Maximum size of stack 

#define MAX 100 

class Stack { 
private: 
	int top; 
	// Array to store stack elements 
	int arr[MAX]; 

public: 
	// Constructor to initialize top as -1 
	Stack() { top = -1; } 

	// Function to push an element to the stack 
	void push(int x) 
	{ 
		if (top == MAX - 1) { 
			cout << "Stack overflow" << endl; 
			return; 
		} 
		arr[++top] = x; 
	} 

	// Function to pop an element from the stack 
	int pop() 
	{ 
		if (top == -1) { 
			cout << "Stack underflow" << endl; 
			return -1; 
		} 
		return arr[top--]; 
	} 

	// Function to check if stack is empty 
	bool isEmpty() { return (top == -1); } 

	// Function to return the top element of the stack 
	int peek() 
	{ 
		if (top == -1) { 
			cout << "Stack is empty" << endl; 
			return -1; 
		} 
		return arr[top]; 
	} 
}; 

int main() 
{ 
	Stack s; 
	s.push(1); 
	s.push(2); 
	s.push(3); 
	s.push(4); 
	s.push(5); 

	cout << "Popped element: " << s.pop() << endl; 
	cout << "Top element: " << s.peek() << endl; 

	return 0; 
}

输出

bash 复制代码

Popped element: 5
Top element: 4

78. 编写一个程序，使用数组实现队列

cpp 复制代码

// C++ Program to implement queue using array 
#include <iostream> 
using namespace std; 

// Maximum size of the queue 
#define MAX 100 

class Queue { 
private: 
	int front, rear; 
	// Array to store queue elements 
	int arr[MAX]; 

public: 
	// Constructor to initialize front and rear as -1 

	Queue() { front = rear = -1; } 
	// Function to add an element to the queue 
	void enqueue(int x) 
	{ 
		if (rear == MAX - 1) { 
			cout << "Error: Queue overflow" << endl; 
			return; 
		} 
		arr[++rear] = x; 
		if (front == -1) 
			front = 0; 
	} 

	// Function to remove an element from the queue 
	int dequeue() 
	{ 
		if (front == -1) { 
			cout << "Queue underflow" << endl; 
			return -1; 
		} 
		int x = arr[front]; 
		if (front == rear) 
			front = rear = -1; 
		else
			front++; 
		return x; 
	} 

	// Function to check if queue is empty 
	bool isEmpty() { return (front == -1); } 

	// Function to return the front element of the queue 
	int peek() 
	{ 
		if (front == -1) { 
			cout << "Queue is empty" << endl; 
			return -1; 
		} 
		return arr[front]; 
	} 
}; 

int main() 
{ 
	Queue q; 
	q.enqueue(1); 
	q.enqueue(2); 
	q.enqueue(3); 
	q.enqueue(4); 
	q.enqueue(5); 

	cout << "Dequeued element: " << q.dequeue() << endl; 
	cout << "Front element: " << q.peek() << endl; 

	return 0; 
}

输出

bash 复制代码

Dequeued element: 1
Front element: 2

79. 编写程序使用队列实现栈

cpp 复制代码

// C++ Program to implement 
// Stack using queue 
#include <bits/stdc++.h> 

using namespace std; 

class Stack { 
	queue<int> q1, q2; 

public: 
	void push(int x) 
	{ 
		// Push x first in empty q2 
		q2.push(x); 

		// Push all the remaining 
		// elements in q1 to q2. 
		while (!q1.empty()) { 
			q2.push(q1.front()); 
			q1.pop(); 
		} 

		// swap the names of two queues 
		queue<int> q = q1; 
		q1 = q2; 
		q2 = q; 
	} 

	void pop() 
	{ 
		// if no elements are there in q1 
		if (q1.empty()) 
			return; 
		q1.pop(); 
	} 

	int top() 
	{ 
		if (q1.empty()) 
			return -1; 
		return q1.front(); 
	} 

	int size() { return q1.size(); } 
}; 

int main() 
{ 
	Stack s; 

	// Inserting elements in Stack 
	s.push(1); 
	s.push(2); 
	s.push(3); 
	s.push(4); 

	cout << "Size: " << s.size() << endl; 
	cout << s.top() << endl; 
	s.pop(); 
	cout << s.top() << endl; 
	s.pop(); 
	cout << s.top() << endl; 

	cout << "Size: " << s.size() << endl; 
	return 0; 
}

输出

bash 复制代码

Size: 4
4
3
2
Size: 2

80. 用STL中的链表写一个程序来实现栈

cpp 复制代码

// C++ Program to implement 
// stack using list 
#include <bits/stdc++.h> 

using namespace std; 

// Template declared 
template <typename T> class Stack { 
public: 
	list<T> l; 
	int cs = 0; 
	// current size of the stack 

	// pushing an element into the stack 
	void push(T d) 
	{ 
		cs++; 
		// increasing the current size of the stack 
		l.push_front(d); 
	} 

	// popping an element from the stack 
	void pop() 
	{ 
		if (cs <= 0) { 
			// cannot pop us stack does not contain an 
			// elements 
			cout << "Stack empty" << endl; 
		} 
		else { 
			// decreasing the current size of the stack 
			cs--; 
			l.pop_front(); 
		} 
	} 

	// if current size is 0 then stack is empty 
	bool empty() { return cs == 0; } 

	// getting the element present at the top of the stack 
	T top() { return l.front(); } 
	int size() 
	{ 
		// getting the size of the stack 
		return cs; 
	} 

	// printing the elements of the stack 
	void print() 
	{ 
		for (auto x : l) { 
			cout << x << endl; 
		} 
	} 
}; 
int main() 
{ 
	// Inserting elements in stack 
	Stack<int> s; 
	s.push(1); 
	s.push(2); 
	s.push(3); 
	s.push(4); 

	cout << "Size: " << s.size() << endl; 
	cout << "Top element:" << s.top() << endl; 
	s.pop(); 
	cout << "Top element:" << s.top() << endl; 
	s.pop(); 
	cout << "Top element:" << s.top() << endl; 
	cout << "Size:" << s.size() << endl; 
	return 0; 
}

输出

bash 复制代码

Size: 4
Top element:4
Top element:3
Top element:2
Size:2

81. 编写一个程序，判断一个数组是否是另一个数组的子集

cpp 复制代码

// C++ Program to check if 
// Array is a subset of another array or not 

#include <iostream> 
using namespace std; 

bool isSubset(int arr1[], int arr2[], int m, int n) 
{ 
	int i = 0; 
	int j = 0; 
	for (i = 0; i < n; i++) { 
		for (j = 0; j < m; j++) { 
			if (arr2[i] == arr1[j]) 
				break; 
		} 

		if (j == m) 
			return 0; 
	} 

	return 1; 
} 

int main() 
{ 
	int arr1[] = { 1, 11, 31, 21, 30, 17 }; 
	int arr2[] = { 11, 30, 17, 1 }; 

	int m = sizeof(arr1) / sizeof(arr1[0]); 
	int n = sizeof(arr2) / sizeof(arr2[0]); 

	if (isSubset(arr1, arr2, m, n)) 
		cout << "arr2 is subset of arr1 "; 
	else
		cout << "arr2 is not a subset of arr1"; 

	return 0; 
}

输出

bash 复制代码

arr2 is subset of arr1

82. Write a Program for Finding the Circular Rotation of an Array by K Positions

cpp 复制代码

// C++ Program for Finding 
// Circular rotation of an array 
// by K positions 
#include <iostream> 
using namespace std; 

void Rotate(int arr[], int k, int n) 
{ 
	// temp array 
	int temp[n]; 

	// Keepig track of the current index 
	// of temp[] 
	int t = 0; 

	// Storing the n - d elements of 
	// array arr[] to the front of temp[] 
	for (int i = k; i < n; i++) { 
		temp[t] = arr[i]; 
		t++; 
	} 

	// Storing the first d elements of array arr[] 
	// into temp 
	for (int i = 0; i < k; i++) { 
		temp[t] = arr[i]; 
		t++; 
	} 

	// Copying the elements of temp[] in arr[] 
	for (int i = 0; i < n; i++) { 
		arr[i] = temp[i]; 
	} 
} 

void print_array(int arr[], int n) 
{ 
	for (int i = 0; i < n; i++) { 
		cout << arr[i] << " "; 
	} 
} 

int main() 
{ 
	int arr[] = { 1, 2, 3, 4, 5 }; 
	int N = sizeof(arr) / sizeof(arr[0]); 
	int k = 2; 

	// Function calling 
	Rotate(arr, k, N); 
	print_array(arr, N); 

	return 0; 
}

输出

bash 复制代码

3 4 5 1 2

83. 编写一个程序，按升序对前半部分进行排序，按降序对后半部分进行排序

cpp 复制代码

// C++ Program to Sort first half 
// in ascending order and second half in descending 
#include <iostream> 
using namespace std; 

void ascDecFunc(int a[], int n) 
{ 
	int temp; 
	for (int i = 0; i < n - 1; i++) { 
		for (int j = 0; j < n / 2; j++) { 
			if (a[j] > a[j + 1]) { 
				temp = a[j]; 
				a[j] = a[j + 1]; 
				a[j + 1] = temp; 
			} 
		} 

		for (int j = n / 2; j < n - 1; j++) { 
			if (a[j] < a[j + 1]) { 
				temp = a[j]; 
				a[j] = a[j + 1]; 
				a[j + 1] = temp; 
			} 
		} 
	} 

	for (int i = 0; i < n; i++) 
		cout << a[i] << " "; 
} 

int main() 
{ 
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; 
	int len = sizeof(arr) / sizeof(arr[0]); 

	ascDecFunc(arr, len); 

	return 0; 
}

输出

bash 复制代码

1 2 3 4 8 7 6 5

84.编写程序逆序打印给定字符串

cpp 复制代码

// C++ program to demonstrate reverse 
// of a string using Last to First 
#include <iostream> 
using namespace std; 

void reverse(string str) 
{ 
	for (int i = str.length() - 1; i >= 0; i--) 
		cout << str[i]; 
} 

int main(void) 
{ 
	string str = "GeeksforGeeks"; 

	reverse(str); 

	return (0); 
}

输出

bash 复制代码

skeeGrofskeeG

85. 编写一个程序，使用递归打印一个字符串的所有排列

cpp 复制代码

// C++ Program to Print 
// Permutaions of string 
#include <iostream> 
#include <string> 
using namespace std; 

void permute(string s, string answer) 
{ 
	if (s.length() == 0) { 
		cout << answer << endl; 
		return; 
	} 
	for (int i = 0; i < s.length(); i++) { 
		char ch = s[i]; 
		string left = s.substr(0, i); 
		string right = s.substr(i + 1); 
		string result = left + right; 
		permute(result, answer + ch); 
	} 
} 

int main() 
{ 
	string s = "ABC"; 
	string answer = ""; 

	permute(s, answer); 
	return 0; 
}

输出

bash 复制代码

ABC
ACB
BAC
BCA
CAB
CBA

86. 编写一个程序，按字典序打印给定字符串的所有排列

cpp 复制代码

// C++ Program to Print all permutations 
// Of a given string in lexicographically sorted order 
#include <bits/stdc++.h> 
using namespace std; 

int compare(const void* a, const void* b) 
{ 
	return (*(char*)a - *(char*)b); 
} 

void swap(char* a, char* b) 
{ 
	char t = *a; 
	*a = *b; 
	*b = t; 
} 

int findCeil(char str[], char first, int l, int h) 
{ 
	int ceilIndex = l; 

	for (int i = l + 1; i <= h; i++) 
		if (str[i] > first && str[i] < str[ceilIndex]) 
			ceilIndex = i; 

	return ceilIndex; 
} 

void Permutations(char str[]) 
{ 
	int size = strlen(str); 

	qsort(str, size, sizeof(str[0]), compare); 

	bool isFinished = false; 
	while (!isFinished) { 
		cout << str << endl; 
		int i; 

		for (i = size - 2; i >= 0; --i) 
			if (str[i] < str[i + 1]) 
				break; 

		if (i == -1) 
			isFinished = true; 
		else { 
			int ceilIndex 
				= findCeil(str, str[i], i + 1, size - 1); 
			swap(&str[i], &str[ceilIndex]); 
			qsort(str + i + 1, size - i - 1, sizeof(str[0]), 
				compare); 
		} 
	} 
} 

int main() 
{ 
	char str[] = "XYZ"; 
	Permutations(str); 
	return 0; 
}

输出

bash 复制代码

XYZ
XZY
YXZ
YZX
ZXY
ZYX

87. 编写一个程序，删除代数表达式中的括号

cpp 复制代码

// C++ Program to remove brackets from an algebraic exp 
#include <iostream> 
#include <string> 

using namespace std; 

string remove_brackets(string str) 
{ 
	string result = ""; 
	for (char c : str) { 
		if (c != '(' && c != ')') { 
			result += c; 
		} 
	} 
	return result; 
} 

int main() 
{ 
	string str = "Geeks)(for)(geeks"; 

	cout << "Without brackets: " << remove_brackets(str) 
		<< endl; 

	return 0; 
}

88. 对单链表执行插入、删除和打印操作

cpp 复制代码

// C++ Program to perform insertion, deletion, and print 
// operations in LL 
#include <iostream> 

using namespace std; 

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

Node* head = nullptr; 

// Function to insert node in LL 
void insert(int data) 
{ 
	Node* newNode = new Node(); 
	newNode->data = data; 
	newNode->next = head; 
	head = newNode; 
} 
// function to delete node of LL 
void deleteNode(int data) 
{ 
	Node *temp = head, *prev = nullptr; 
	if (temp != nullptr && temp->data == data) { 
		head = temp->next; 
		delete temp; 
		return; 
	} 
	while (temp != nullptr && temp->data != data) { 
		prev = temp; 
		temp = temp->next; 
	} 
	if (temp == nullptr) 
		return; 
	prev->next = temp->next; 
	delete temp; 
} 

// function to print LL 
void printList() 
{ 
	Node* temp = head; 
	while (temp != nullptr) { 
		cout << temp->data << " "; 
		temp = temp->next; 
	} 
	cout << endl; 
} 

int main() 
{ 
	insert(1); 
	insert(2); 
	insert(3); 
	insert(4); 
	insert(5); 
	cout << "Linked List is \n"; 

	printList(); 
	deleteNode(3); 
	cout << "Linked List after deletion of 3: "; 
	printList(); 

	return 0; 
}

输出

bash 复制代码

Linked List is 
5 4 3 2 1 
Linked List after deletion of 3: 5 4 2 1

89. 对双链表执行插入、删除和打印操作

cpp 复制代码

// C++ Program to implement insert, delete, and print 
// operation in doubly linked list 
#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; 
}

输出

bash 复制代码

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

90. 对循环链表执行插入、删除和打印操作

cpp 复制代码

// C++ Program to implement insert, delete, and print in 
// circular linked list 
#include <iostream> 

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

class CircularLinkedList { 
private: 
	Node* head; 

public: 
	CircularLinkedList() 
		: head(NULL) 
	{ 
	} 

	void insertAtStart(int data) 
	{ 
		Node* newNode = new Node; 
		newNode->data = data; 
		newNode->next = head; 

		if (head == NULL) { 
			head = newNode; 
			newNode->next = head; 
		} 
		else { 
			Node* temp = head; 
			while (temp->next != head) 
				temp = temp->next; 
			temp->next = newNode; 
			head = newNode; 
		} 
	} 

	void deleteNode(int data) 
	{ 
		Node* temp = head; 
		if (temp == NULL) 
			return; 

		if (temp->next == head) { 
			head = NULL; 
			delete temp; 
			return; 
		} 

		Node* prev = NULL; 
		while (temp->next != head && temp->data != data) { 
			prev = temp; 
			temp = temp->next; 
		} 

		if (temp->data != data) 
			return; 

		prev->next = temp->next; 
		if (temp == head) 
			head = temp->next; 
		delete temp; 
	} 

	void printList() 
	{ 
		Node* temp = head; 
		while (temp->next != head) { 
			std::cout << temp->data << " "; 
			temp = temp->next; 
		} 
		std::cout << temp->data << std::endl; 
	} 
}; 

int main() 
{ 
	CircularLinkedList cll; 

	cll.insertAtStart(1); 
	cll.insertAtStart(2); 
	cll.insertAtStart(3); 
	cll.insertAtStart(4); 
	cll.insertAtStart(5); 

	std::cout << "Original Circular Linked list "; 
	cll.printList(); 

	cll.deleteNode(2); 

	std::cout << "Circular Linked List after deletion "; 
	cll.printList(); 

	return 0; 
}

输出

bash 复制代码

Original Circular Linked list 5 4 3 2 1
Circular Linked List after deletion 5 4 3 1

91. 二叉树的中序遍历

cpp 复制代码

// C++ program Inorder Traversal 
#include <bits/stdc++.h> 
using namespace std; 

/* A binary tree node has data, pointer to left child 
and a pointer to right child */

struct Node { 
	int data; 
	struct Node *left, *right; 
}; 

// Utility function to create a new tree node 
Node* newNode(int data) 
{ 
	Node* temp = new Node; 
	temp->data = data; 
	temp->left = temp->right = NULL; 
	return temp; 
} 

/* Given a binary tree, print its nodes in inorder*/
void printInorder(struct Node* node) 
{ 
	if (node == NULL) 
		return; 

	/* first recur on left child */
	printInorder(node->left); 

	/* then print the data of node */
	cout << node->data << " "; 

	/* now recur on right child */
	printInorder(node->right); 
} 

int main() 
{ 
	struct Node* root = newNode(1); 
	root->left = newNode(2); 
	root->right = newNode(3); 
	root->left->left = newNode(4); 
	root->left->right = newNode(5); 

	// Function call 
	cout << "Inorder traversal of binary tree is \n"; 
	printInorder(root); 

	return 0; 
}

输出

bash 复制代码

Inorder traversal of binary tree is 
4 2 5 1 3

92. 编写程序求一组正整数的所有子集

cpp 复制代码

// C++ Program to find all subsets from the given set of 
// positive integers 
#include <bits/stdc++.h> 

using namespace std; 

void find_subset(vector<int>& A, vector<vector<int> >& ans, 
				vector<int>& subset, int index) 
{ 
	ans.push_back(subset); 
	for (int i = index; i < A.size(); i++) { 

		subset.push_back(A[i]); 
		find_subset(A, ans, subset, i + 1); 
		subset.pop_back(); 
	} 

	return; 
} 

vector<vector<int> > subsets(vector<int>& A) 
{ 
	vector<int> subset; 
	vector<vector<int> > ans; 

	int index = 0; 
	find_subset(A, ans, subset, index); 

	return ans; 
} 

int main() 
{ 
	vector<int> array = { 1, 2, 3, 4, 5 }; 

	vector<vector<int> > ans = subsets(array); 

	for (int i = 0; i < ans.size(); i++) { 
		for (int j = 0; j < ans[i].size(); j++) 
			cout << ans[i][j] << " "; 
		cout << endl; 
	} 

	return 0; 
}

输出：

bash 复制代码

93. 二叉树的先序遍历

cpp 复制代码

// C++ program for preorder traversal 
#include <bits/stdc++.h> 
using namespace std; 

/* A binary tree node has data, pointer to left child 
and a pointer to right child */
struct Node { 
	int data; 
	struct Node *left, *right; 
}; 

// Utility function to create a new tree node 
Node* newNode(int data) 
{ 
	Node* temp = new Node; 
	temp->data = data; 
	temp->left = temp->right = NULL; 
	return temp; 
} 

/* Given a binary tree, print its nodes in preorder*/
void printPreorder(struct Node* node) 
{ 
	if (node == NULL) 
		return; 

	/* first print data of node */
	cout << node->data << " "; 

	/* then recur on left subtree */
	printPreorder(node->left); 

	/* now recur on right subtree */
	printPreorder(node->right); 
} 

int main() 
{ 
	struct Node* root = newNode(1); 
	root->left = newNode(2); 
	root->right = newNode(3); 
	root->left->left = newNode(4); 
	root->left->right = newNode(5); 

	// Function call 
	cout << "Preorder traversal of binary tree is \n"; 
	printPreorder(root); 

	return 0; 
}

输出

bash 复制代码

Preorder traversal of binary tree is 
1 2 4 5 3

94. 二叉树的后序遍历

cpp 复制代码

// C++ program for post order traversal 
#include <bits/stdc++.h> 
using namespace std; 

/* A binary tree node has data, pointer to left child 
and a pointer to right child */
struct Node { 
	int data; 
	struct Node *left, *right; 
}; 

// Utility function to create a new tree node 
Node* newNode(int data) 
{ 
	Node* temp = new Node; 
	temp->data = data; 
	temp->left = temp->right = NULL; 
	return temp; 
} 

/* Given a binary tree, print its nodes according to the 
"bottom-up" postorder traversal. */
void printPostorder(struct Node* node) 
{ 
	if (node == NULL) 
		return; 

	// first recur on left subtree 
	printPostorder(node->left); 

	// then recur on right subtree 
	printPostorder(node->right); 

	// now deal with the node 
	cout << node->data << " "; 
} 

int main() 
{ 
	struct Node* root = newNode(1); 
	root->left = newNode(2); 
	root->right = newNode(3); 
	root->left->left = newNode(4); 
	root->left->right = newNode(5); 

	// Function call 
	cout << "Postorder traversal of binary tree is \n"; 
	printPostorder(root); 

	return 0; 
}

输出

bash 复制代码

Postorder traversal of binary tree is 
4 5 2 3 1

95. 二叉树的层级遍历

cpp 复制代码

// C++ program for post order traversal 
#include <bits/stdc++.h> 
using namespace std; 

/* A binary tree node has data, pointer to left child 
and a pointer to right child */
struct Node { 
	int data; 
	struct Node *left, *right; 
}; 

// Utility function to create a new tree node 
Node* newNode(int data) 
{ 
	Node* temp = new Node; 
	temp->data = data; 
	temp->left = temp->right = NULL; 
	return temp; 
} 

/* Given a binary tree, print its nodes according to the 
"bottom-up" postorder traversal. */
void printLevelOrder(struct Node* node) 
{ 
	if (node == NULL) 
		return; 
	queue<struct Node*> q; 
	while (node) { 
		if (node->left) { 
			q.push(node->left); 
		} 
		if (node->right) { 
			q.push(node->right); 
		} 
		cout << node->data << " "; 
		node = q.front(); 
		q.pop(); 
	} 
} 

int main() 
{ 
	struct Node* root = newNode(1); 
	root->left = newNode(2); 
	root->right = newNode(3); 
	root->left->left = newNode(4); 
	root->left->right = newNode(5); 

	// Function call 
	cout << "Levelorder traversal of binary tree is \n"; 
	printLevelOrder(root); 

	return 0; 
}

输出

bash 复制代码

Levelorder traversal of binary tree is 
1 2 3 4 5

96. 编写程序打印二叉树的俯视图

cpp 复制代码

// C++ program for top view of a binary tree 
#include <bits/stdc++.h> 
using namespace std; 

// node data type 
struct Node { 
	Node* left; 
	Node* right; 
	int hd; 
	int data; 
}; 

// utility function to create new node 
Node* newNode(int key) 
{ 
	Node* node = new Node(); 
	node->left = node->right = NULL; 
	node->data = key; 
	return node; 
} 

// function to print top view of a binary tree 
void topView(Node* root) 
{ 
	if (root == NULL) { 
		return; 
	} 
	queue<Node*> q; 
	map<int, int> m; 
	int hd = 0; 
	root->hd = hd; 

	q.push(root); 

	while (q.size()) { 
		hd = root->hd; 

		if (m.count(hd) == 0) 
			m[hd] = root->data; 
		if (root->left) { 
			root->left->hd = hd - 1; 
			q.push(root->left); 
		} 
		if (root->right) { 
			root->right->hd = hd + 1; 
			q.push(root->right); 
		} 
		q.pop(); 
		root = q.front(); 
	} 

	// printing top view 
	for (auto i = m.begin(); i != m.end(); i++) { 
		cout << i->second << " "; 
	} 
} 

// Driver code 
int main() 
{ 
	// new binary tree 
	Node* root = newNode(1); 
	root->left = newNode(2); 
	root->right = newNode(3); 
	root->left->left = newNode(4); 
	root->right->right = newNode(5); 

	topView(root); 
	return 0; 
}

输出

bash 复制代码

4 2 1 3 5

97. 编写程序打印二叉树的仰视图

cpp 复制代码

// C++ program for bottom view of a binary tree 
#include <bits/stdc++.h> 
using namespace std; 

// node data type 
struct Node { 
	Node* left; 
	Node* right; 
	int data; 
	int hd; 
}; 

// utility function for new node 
Node* newNode(int key) 
{ 
	Node* node = new Node(); 
	node->data = key; 
	node->left = node->right = NULL; 
	node->hd = 0; 

	return node; 
} 

// function to print bottom view 
void bottomView(Node* root) 
{ 
	if (root == NULL) 
		return; 

	queue<Node*> q; 
	map<int, int> m; 

	int hd = 0; 

	root->hd = hd; 
	q.push(root); 

	while (!q.empty()) { 
		Node* temp = q.front(); 
		q.pop(); 

		hd = temp->hd; 

		m[hd] = temp->data; 

		if (temp->left != NULL) { 
			temp->left->hd = hd - 1; 
			q.push(temp->left); 
		} 

		if (temp->right != NULL) { 
			temp->right->hd = hd + 1; 
			q.push(temp->right); 
		} 
	} 

	// printing top view 
	for (auto i = m.begin(); i != m.end(); ++i) 
		cout << i->second << " "; 
} 

// Driver Code 
int main() 
{ 
	Node* root = newNode(1); 
	root->left = newNode(2); 
	root->right = newNode(3); 
	root->left->left = newNode(4); 
	root->right->right = newNode(5); 

	bottomView(root); 
	return 0; 
}

输出

bash 复制代码

4 2 1 3 5

98. 编写程序打印二叉树的左视图

cpp 复制代码

// C++ program to print left view of a binary tree 
#include <bits/stdc++.h> 
using namespace std; 

// node datatype 
struct Node { 
	Node* left; 
	Node* right; 
	int data; 
}; 

// utility function to create a new node 
Node* newNode(int key) 
{ 
	Node* node = new Node; 
	node->data = key; 
	node->left = node->right = NULL; 
	return node; 
} 

// function to print left view 
void leftView(Node* root) 
{ 
	if (!root) { 
		return; 
	} 

	queue<Node*> q; 
	q.push(root); 

	while (!q.empty()) { 
		int n = q.size(); 

		for (int i = 1; i <= n; i++) { 
			Node* temp = q.front(); 
			q.pop(); 

			if (i == 1) 
				cout << temp->data << " "; 

			if (temp->left != NULL) 
				q.push(temp->left); 

			if (temp->right != NULL) 
				q.push(temp->right); 
		} 
	} 
} 

// Driver code 
int main() 
{ 

	Node* root = newNode(1); 
	root->left = newNode(2); 
	root->right = newNode(3); 
	root->left->left = newNode(4); 
	root->right->right = newNode(5); 

	leftView(root); 
}

输出

bash 复制代码

1 2 4

99. 编写程序打印二叉树的右视图

cpp 复制代码

// C++ program to print the right view of a binary tree 
#include <bits/stdc++.h> 
using namespace std; 

// node data type 
struct Node { 
	Node* left; 
	Node* right; 
	int data; 
}; 

// utility function to create new node 
Node* newNode(int key) 
{ 
	Node* node = new Node; 
	node->data = key; 
	node->left = node->right = NULL; 
	return node; 
} 

// function to print right view of a binary tree 
void rightView(Node* root) 
{ 
	if (root == NULL) { 
		return; 
	} 

	queue<Node*> q; 
	q.push(root); 

	while (!q.empty()) { 

		int n = q.size(); 

		while (n--) { 

			Node* x = q.front(); 
			q.pop(); 

			if (n == 0) { 
				cout << x->data << " "; 
			} 
			if (x->left) { 
				q.push(x->left); 
			} 
			if (x->right) { 
				q.push(x->right); 
			} 
		} 
	} 
} 

// Driver code 
int main() 
{ 

	Node* root = newNode(1); 
	root->left = newNode(2); 
	root->right = newNode(3); 
	root->left->left = newNode(4); 
	root->right->right = newNode(5); 

	rightView(root); 
}

输出

bash 复制代码

1 3 5

100. 编写程序将中缀表达式转换为后缀表达式

cpp 复制代码

// C++ program for infix expression to postfix expression 
// conversion 
#include <bits/stdc++.h> 
using namespace std; 

// infix to postfix conversion 
// supported operators => + - * / 
string infixToPostfix(string& expression) 
{ 
	// string to store postfix expression 
	string postfix; 
	// operator stack 
	stack<char> ope_stack; 
	// operator precedence map 
	unordered_map<char, int> pre = { { '+', 1 }, 
									{ '-', 1 }, 
									{ '*', 2 }, 
									{ '/', 2 }, 
									{ '(', 0 } }; 

	int length = expression.length(); 

	for (int i = 0; i < length; i++) { 
		char c = expression[i]; 
		// checking operands 
		if ((c >= 92 && c <= 122) || (c >= 48 && c <= 57)) { 
			postfix.push_back(c); 
		} 
		// checking braces 
		else if (c == '(') { 
			ope_stack.push(c); 
		} 
		else if (c == ')') { 
			while (ope_stack.top() != '(') { 
				postfix.push_back(ope_stack.top()); 
				ope_stack.pop(); 
			} 
			ope_stack.pop(); 
		} 
		// checking operators 
		else { 
			while (!ope_stack.empty() 
				&& pre.at(c) < pre.at(ope_stack.top())) { 
				postfix.push_back(ope_stack.top()); 
				ope_stack.pop(); 
			} 
			ope_stack.push(c); 
		} 
	} 

	// popping whole stack at the end 
	while (!ope_stack.empty()) { 
		postfix.push_back(ope_stack.top()); 
		ope_stack.pop(); 
	} 

	return postfix; 
} 

// driver code 
int main() 
{ 
	string s = "a*b+(c-d)"; 
	cout << infixToPostfix(s); 

	return 0; 
}

输出

bash 复制代码

ab*cd-+

Top100 C++编程面试问题

文章目录

1. 编写程序判断数字是正数还是负数

2. 编写程序找出三个数中最大的一个

3. 编写程序检查数字是偶数还是奇数

4. 编写程序计算字符的ASCII值

5. 编写程序检查字符是元音还是辅音

6. 编写程序检查一个字符是否为字母表

7. 编写程序，在不使用 strlen()函数的情况下计算字符串的长度

8. 编写程序来切换字符串中的每个字符

9. 编写程序来统计元音的数量

10. 编写程序删除字符串中的元音

11. 编写程序删除字符串中除字母以外的所有字符

12. 编写程序删除字符串中的空格

13. 编写程序求前N个自然数的和

14. 编写一个用循环求数的阶乘的程序

15. 编写程序判断是否为闰年

16. 编写程序判断是否为素数

17. 编写程序检查是否为回文

18. 编写程序检查一个数字是否为Armstrong数

19. 编写程序计算斐波那契数列的第N项

20. 编写程序计算两个数的最大公约数

21. 编写程序计算两个数字的最小公倍数（LCM）

22. 编写程序求二次方程的根

23. 编写程序查找数组中的最小和最大的元素

24. 编写程序查找数组中第二小的元素

25. 编写程序计算数组所有元素的和

26. 编写程序检查给定字符串是否为回文

27. 编写程序检查两个字符串是否互为异位字符串

28. 编写程序打印以下的钻石图案

29. 编写打印金字塔图案的程序

30. 编写程序打印沙漏图案

31. 编写程序打印旋转沙漏图案

32. 编写打印简单金字塔图案的程序

33. 编写程序打印倒金字塔

34. 编写程序打印三角形星形图案

35. 编写程序打印Floyd三角形

36. 编写程序打印Pascal三角形

37. 编写程序逆序打印给定字符串

38. 编写C++程序，使用递归逆序打印给定字符串

39. 编写程序，使用递归判断给定的字符串是否为回文

40. 使用递归计算字符串长度

41. 使用递归计算一个数的阶乘

42. 编写程序计算字符串中数字的总和

43. 编写一个程序，在不使用分号的情况下打印N以内的所有自然数

44. 编写一个程序，在不使用任何额外变量的情况下交换两个变量的值

45. 编写程序，使用补码(~)运算符打印无符号整数类型的最大值

46. 不使用算术或比较运算符，检查两个数字的相等性

47. 编写一个程序，在不使用比较运算符的情况下求两个数的最大值和最小值

48. 编写八进制到十进制转换程序

49. 编写十六进制到十进制转换的程序

50. 编写一个十进制到二进制转换的程序

51. 编写一个程序进行十进制八进制转换

52. 编写十进制到十六进制转换程序

53. 编写二进制到八进制转换程序

54. 编写八进制到二进制转换的程序

55. 编写一个程序来实现封装的使用

56. 编写一个实现抽象概念的程序

57. 编写程序实现编译时多态性或函数重载的概念

58. 编写一个实现运算符重载概念的程序

59. 编写一个程序来实现函数重写或运行时多态性的概念

60. 编写实现单继承的程序

61. 编写程序创建一个复数类

62. 编写一个程序来实现英寸-英尺系统

63. 编写程序实现冒泡排序

64. 编写程序实现插入排序

65. 编写程序以实现选择排序

66. 编写程序实现归并排序

67. 编写程序实现快速排序

68. 编写程序实现线性搜索

69. 编写一个程序实现二分查找

70. 编写一个程序来查找vector中给定元素的下标

71. 编写程序，使用STL删除数组中重复的元素

72. 用STL编写数组降序排序程序

73. 编写程序计算给定字符串中每个单词的频率

74. 编写一个程序，按原始顺序查找数组最大的 k 个元素

75. 编写一个程序，使用STL找出给定集合的所有不同子集

76. 编写一个程序遍历一个队列，但不删除其中的元素

77. 编写一个程序，使用数组实现栈

78. 编写一个程序，使用数组实现队列

7. 编写程序，在不使用 `strlen()`函数的情况下计算字符串的长度