Top100 C++编程面试问题

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

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

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

// C++ Program to check whether a number is positive or 
// negative 
#include  
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; 
}

输出：

-100 is a negative number.

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

// C++ program to find greatest 
// among three numbers using 
#include  
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; 
}

输出：

The Greatest Among Three Numbers is : 30

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

// C++ program to check 
// for even or odd 
#include  
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; 
}

输出：

Odd

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

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

int main() 
{ 
	char ch; 

	ch = 'A'; 

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

	return 0; 
}

输出：

The ASCII value of A is 65

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

// C++ Program to print whether a character is vowel or not 
#include  
#include  
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; 
}

输出：

e is a vowel.

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

// C++ program to print whether a character is an alphabet 
// or not 
#include  
#include  
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; 
}

输出：

a is an alphabet.

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

// C++ Program to find the length of a string without using 
// strlen() 
#include  
#include  
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; 
}

输出：

The length of the string is: 13

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

// C++ Program to toggle string 
#include  
#include  
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; 
}

输出：

Toggled string: gEEKSFORgEEKS

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

// C++ Program to count the number of vowels 
#include  
#include  
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; 
}

输出：

Number of vowels in the string: 9

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

// C++ Program to remove the vowels from a string 
#include  
#include  
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; 
}

输出：

String without vowels: GksfrGks

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

// C++ Programto remove all characters from a string except 
// alphabets 
#include  
#include  
#include  

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; 
}

输出：

Alphabets only: Geeksforgeeks

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

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

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; 
}

输出：

Without spaces: Gfgtothemoon

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

// C++ program to find 
// Sum of first 
// n natural numbers. 
#include  
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; 
}

输出：

28

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

// C++ program to find factorial using loops 
#include  
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; 
}

输出：

120

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

// C++ program to check if a given 
// year is leap year or not 
#include  
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; 
}

输出：

Leap Year

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

// C++ program to check if a 
// Number is prime 
#include  
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; 
}

输出：

false
true

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

// C++ program to check if a 
// number is Palindrome or not 
#include  
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; 
}

输出：

Yes

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

// C++ Program to check 
// if number is Armstrong 
// or not 
#include  
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; 
}

输出：

Yes, it is Armstrong Number

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

// C++ Program to Find the 
// Nth Term of the Fibonacci Series 
#include  
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; 
}

输出：

233

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

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

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; 
}

输出：

GCD: 3

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

// C++ program to 
// Find LCM of two numbers 
#include  
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; 
}

输出：

LCM : 312

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

// C++ program to find 
// Roots of a quadratic equation 
#include  
#include  
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; 
}

输出：

Roots are real and same 
-2

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

// C++ code to for 
// Finding the minimum 
// And maximum of the array 
#include  
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; 
}

输出：

Min: 1
Max: 5

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

// C++ program to find 
// Second smallest elements 
#include  
#include  
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; 
}

输出：

Second smallest element is 10

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

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

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

// C++ program for checking 
// if it is Palindrome or not 
#include  
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; 
}

输出：

Yes

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

// C++ program to check if two strings 
// Are anagrams of each other 
#include  
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; 
}

输出：

The two strings are not anagram of each other

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

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

// C++ program to print 
// Diamond shape 
#include  
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; 
}

输出：

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

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

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

// C++ Program to 
// Print Pyramid pattern 
#include  
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; 
}

输出：

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

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

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

// C Program to print hourglass pattern 
#include  
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; 
}

输出：

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

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

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

// C++ Program to print 
// star pattern given 
#include  
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; 
}

输出：

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

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

// C++ Program to print a simple pyramid 
#include  
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; 
}

输出：

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

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

// C++ Program to print inverted pyramid 
#include  
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; 
}

输出：

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

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

// C++ Program to print a triangle star patter 
#include  
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; 
}

输出：

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

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

// C Program to print the Floyd's Triangle 
#include  

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; 
}

输出：

1 
2 3 
4 5 6 
7 8 9 10 

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

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

// C++ program to print 
// Pascal’s Triangle 
#include  
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; 
}

输出：

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

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

// C++ Program to reversea string 
#include  
#include  
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; 
}

输出：

Reverse of the string: skeeGrofskeeG

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

// C++ Program to 
// Reverse string using 
// recursion 
#include  
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; 
}

输出：

skeeGrofskeeG

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

// C++ program to check 
// Whether a given number 
// Is palindrome or not 
#include  
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; 
}

输出：

Yes

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

// C++ Program for calculating 
// the length of string 
#include  
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; 
}

输出：

13

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

// C++ program to calculate 
// Factorial of given number 
#include  
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; 
}

输出：

Factorial of 15 is 1307674368000

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

// C++ Program to count the sume of numbers in a string 
#include  
#include  
#include  

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; 
}

输出：

Sum of numbers: 10

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

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

using namespace std; 
#define N 10 

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

输出：

1 2 3 4 5 6 7 8 9 10 

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

// C++ program to check 
// If two numbers are equal 
#include  
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; 
}

输出：

X : 3
Y : 4

After:
X : 4
Y : 3

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

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

using namespace std; 

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

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

	return 0; 
}

输出：

Max value possible : 4294967295

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

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

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

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

	return 0; 
}

输出

Equal

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

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

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; 
}

输出：

max :10
min :5

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

// C++ Program to convert ocatal to decimal 
#include  
#include  

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; 
}

输出：

Decimal equivalent is: 55

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

// C++ Program to convert hexadecimal to decimal conversion 
#include  
#include  

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; 
}

输出：

Decimal equivalent 103

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

// c++ program to convert decimal to binary 
#include  
#include  

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; 
}

输出：

Binary equivalent: 00000000000000000000000000000111

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

// C++ Program to convert decimal to octal equivalent 
#include  
#include  

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; 
}

输出

Octal equivalent 67

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

// C++ program to convert decimal to hexadecimal 
#include  
#include  
#include  

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; 
}

输出：

Hexadecimal equivalent: 67

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

// C++ implementation to convert a binary number 
// to octal number 
#include  
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; 
}

输出：

Octal number = 1712241.26633

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

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

#include  
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; 
}

输出：

Equivalent Binary Value = 011100101

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

// C++ Program to implement 
// The concept of Encapsulation 
#include  
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; 
}

输出：

13

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

// C++ Program to implement 
// Working of Abstraction 
#include  
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; 
}

输出：

p = 1
q = 2

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

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

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; 
}

输出

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

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

// C++ program to demonstrate 
// Operator Overloading 
#include  
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(); 
}

输出：

18 + 10i

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

// C++ program for implementation 
// of Function Overloading or 
// Compile time Polymorphism 
#include  
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; 
}

输出：

print derived class
show base class

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

// C++ Program to implement 
// Single level inheritance 
#include  
#include  

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; 
}

输出

132451    XYZ    ABC    100000

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

// C++ Program to create a class of complex numbers 
#include  
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; 
}

输出

11 + i12
5 + i8
16 + i20

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

// C++ Program to create a class of inchFeet length system 
#include  
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; 
}

输出

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

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

// C++ program to implement 
// of Bubble sort 
#include  
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; 
}

输出

Sorted array: 1 2 3 4 5 

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

// C++ program to implement 
// Insertion sort 
#include  
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; 
}

输出

Sorted array:1 2 3 4 5 

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

// C++ program to implement 
// Selection sort 
#include  
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; 
}

输出

Sorted array: 1 2 3 4 5 

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

// C++ program to implement 
// Merge Sort 
#include  
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; 
}

输出：

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

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

// C++ Program to implement 
// QuickSort 
#include  
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; 
}

输出

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

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

// C++ Program to implement 
// Linear Sort 
#include  
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; 
}

输出：

Element is present at index 5

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

// C++ program to implement 
// Binary Search 
#include  
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; 
}

输出：

Element is present at index 4

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

// C++ program to find the index 
// of an element in a vector 
#include  

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; 
}

输出

Output

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

// C++ program to remove the 
// duplicate elements from the array 
// using STL in C++ 
#include  

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; 
}

输出

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

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

// C++ program to sort Array 
// in descending order 
#include  
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; 
}

输出

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

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

// C++ program to calculate 
// frequency of each word 
// in given string 
#include  
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; 
}

输出

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

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

// C++ program to find k Maximum elements 
#include  
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; 
}

输出

50 45 84 

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

// C++ code for the above approach: 

#include  
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; 
}

输出

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

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

// C++ program to iterate a 
// STL Queue by Creating 
// copy of given queue 
#include  
#include  
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; 
}

输出

Queue elements :
1 2 3 4 5 

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

// C++ Program to implement stacks using array 
#include  
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; 
}

输出

Popped element: 5
Top element: 4

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

// C++ Program to implement queue using array 
#include  
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; 
}

输出

Dequeued element: 1
Front element: 2

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

// C++ Program to implement 
// Stack using queue 
#include  

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; 
}

输出

Size: 4
4
3
2
Size: 2

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

// C++ Program to implement 
// stack using list 
#include  

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; 
}

输出

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

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

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

#include  
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; 
}

输出

arr2 is subset of arr1 

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

// C++ Program for Finding 
// Circular rotation of an array 
// by K positions 
#include  
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; 
}

输出

3 4 5 1 2 

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

// C++ Program to Sort first half 
// in ascending order and second half in descending 
#include  
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; 
}

输出

1 2 3 4 8 7 6 5 

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

// C++ program to demonstrate reverse 
// of a string using Last to First 
#include  
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); 
}

输出

skeeGrofskeeG

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

// C++ Program to Print 
// Permutaions of string 
#include  
#include  
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; 
}

输出

ABC
ACB
BAC
BCA
CAB
CBA

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

// C++ Program to Print all permutations 
// Of a given string in lexicographically sorted order 
#include  
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; 
}

输出

XYZ
XZY
YXZ
YZX
ZXY
ZYX

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

// C++ Program to remove brackets from an algebraic exp 
#include  
#include  

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. 对单链表执行插入、删除和打印操作

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

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; 
}

输出

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

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

// C++ Program to implement insert, delete, and print 
// operation in doubly linked list 
#include  

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 

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

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

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; 
}

输出

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

91. 二叉树的中序遍历

// C++ program Inorder Traversal 
#include  
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; 
}

输出

Inorder traversal of binary tree is 
4 2 5 1 3

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

// C++ Program to find all subsets from the given set of 
// positive integers 
#include  

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; 
}

输出：

1 
1 2 
1 2 3 
1 2 3 4 
1 2 3 4 5 
1 2 3 5 
1 2 4 
1 2 4 5 
1 2 5 
1 3 
1 3 4 
1 3 4 5 
1 3 5 
1 4 
1 4 5 
1 5 
2 
2 3 
2 3 4 
2 3 4 5 
2 3 5 
2 4 
2 4 5 
2 5 
3 
3 4 
3 4 5 
3 5 
4 
4 5 
5 

93. 二叉树的先序遍历

// C++ program for preorder traversal 
#include  
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; 
}

输出

Preorder traversal of binary tree is 
1 2 4 5 3 

94. 二叉树的后序遍历

// C++ program for post order traversal 
#include  
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; 
}

输出

Postorder traversal of binary tree is 
4 5 2 3 1 

95. 二叉树的层级遍历

// C++ program for post order traversal 
#include  
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; 
}

输出

Levelorder traversal of binary tree is 
1 2 3 4 5 

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

// C++ program for top view of a binary tree 
#include  
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; 
}

输出

4 2 1 3 5 

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

// C++ program for bottom view of a binary tree 
#include  
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; 
}

输出

4 2 1 3 5 

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

// C++ program to print left view of a binary tree 
#include  
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); 
}

输出

1 2 4 

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

// C++ program to print the right view of a binary tree 
#include  
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); 
}

输出

1 3 5 

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

// C++ program for infix expression to postfix expression 
// conversion 
#include  
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; 
}

输出

ab*cd-+