目录
一、递归案例
1.递归翻转链表（Python）
2.链表逆序输出（C）
3.链表区间翻转
（1）直接法（C）
（2）递归法（python）
（3）递归法（C）
二、斐波那数列（C）
三、猴子吃桃（C）
四、水仙花数（C）
五、阶乘计算（C）
六、指针参数的使用
七、小球落地
八、常用排序算法
（1）冒泡排序（Bubble Sort）
（2）快速排序（Quick Sort）
（3）希尔排序（Shell's Sort）
（4）插入排序（Insertion Sort）
九、素数問題
一、递归案例
1.递归翻转链表（Python）
from typing import Optionalclass ListNode:def __init__(self, val, next: 'Optional[ListNode]' = None):self.val = valself.next = nextdef reverse(head: Optional[ListNode]):if head is None or head.next is None: # 递归停止的基线条件return headnew_head = reverse(head.next)head.next.next = head # 当前层函数的head节点的后续节点指向当前head节点head.next = None # 当前head节点指向Nonereturn new_head# 创建链表示例
node1 = ListNode(5)
node2 = ListNode(6)
node3 = ListNode(3)
node4 = ListNode(1)
node5 = ListNode(2)node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node5result = reverse(node1)
while result:print(result.val, end=' -> ')result = result.next
print('null')2.链表逆序输出（C）
// 定义链表节点结构体
typedef struct ListNode {int data; struct ListNode *next;
} ListNode;// 辅助函数，用于创建新的链表节点
ListNode* createListNode(int data) {ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));newNode->data = data;newNode->next = NULL;return newNode;
}int List_nixu(ListNode L)
{if(L->next == NULL)return 1;List_nixu(L->next);printf("%d\n",L->data);
}int main() {// 创建链表 1 -> 2 -> 3 -> 4 -> 5ListNode *node5 = createListNode(5);ListNode *node4 = createListNode(4);ListNode *node3 = createListNode(3);ListNode *node2 = createListNode(2);ListNode *node1 = createListNode(1);node1->next = node2;node2->next = node3;node3->next = node4;node4->next = node5;// 反转并打印链表List_nixu(node1);// 释放链表内存free(node1);free(node2);free(node3);free(node4);free(node5);return 0;
}3.链表区间翻转
（1）直接法（C）
#include <stdio.h>
#include <stdlib.h>// 定义链表节点结构体
typedef struct ListNode
{int val;struct ListNode *next;
} ListNode;// 创建新节点
ListNode *createNode(int val)
{ListNode *newNode = (ListNode *)malloc(sizeof(ListNode));newNode->val = val;newNode->next = NULL;return newNode;
}// 反转链表区间(三步走)
void reverseBetween(ListNode *head, int m, int n)
{if (head == NULL || head->next == NULL || m == n)return;// 1.找到m位置的节点和它的前一个节点ListNode *prevM = NULL; // 保存m位置的前一个节点ListNode *nodeM = head; // 保存m位置的节点for (int i = 1; i < m; i++){prevM = nodeM;nodeM = nodeM->next;}// 2.反转从m到n的节点ListNode *prev = NULL;ListNode *curr = nodeM;ListNode *nextM = NULL;for (int i = m; i <= n; i++){nextM = curr->next;curr->next = prev;prev = curr;curr = nextM;}// 3.将反转后的链表接回原链表if (prevM != NULL)prevM->next = prev;elsehead = prev;nodeM->next = nextM;return;
}// 打印链表
void printList(ListNode *head)
{while (head != NULL){printf("%d -> ", head->val);head = head->next;}printf("NULL\n");
}// 释放链表内存
void free_List(ListNode *head)
{while (head != NULL){ListNode *temp = head;head = head->next;free(temp);}
}// 主函数
int main()
{// 创建链表 1 -> 2 -> 3 -> 4 -> 5ListNode *head = createNode(1);head->next = createNode(2);head->next->next = createNode(3);head->next->next->next = createNode(4);head->next->next->next->next = createNode(5);printf("Original List: ");printList(head);// 反转第2个到第4个节点reverseBetween(head, 2, 4);printf("Reversed List: ");printList(head);// 释放链表内存free_List(head);return 0;
}（2）递归法（python）
# 定义链表节点类
class ListNode:def __init__(self, val=0, next=None):self.val = valself.next = nextdef reverseBetween_turtle(head, left, right):def reverseN(head, n):if n == 1:successor = head.nextreturn head, successorlast, successor = reverseN(head.next, n - 1)head.next.next = headhead.next = successorreturn last, successorif left == 1:new_head, _ = reverseN(head, right)return new_headhead.next = reverseBetween_turtle(head.next, left - 1, right - 1)return head# 构建测试链表
node1 = ListNode(1)
node2 = ListNode(2)
node3 = ListNode(3)
node4 = ListNode(4)
node5 = ListNode(5)node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node5new_head = reverseBetween_turtle(node1, 2, 4)
while new_head:print(new_head.val)new_head = new_head.next（3）递归法（C）
#include <stdio.h>
#include <stdlib.h>// 定义链表节点结构体
typedef struct ListNode
{int val;struct ListNode *next;
} ListNode;// 创建新节点
ListNode *createNode(int val)
{ListNode *newNode = (ListNode *)malloc(sizeof(ListNode));newNode->val = val;newNode->next = NULL;return newNode;
}// 递归反转链表区间
void reverseBetween_turtle(ListNode** head, int m, int n) {if (*head == NULL || m == n) return;if (m == 1) {ListNode* prev = NULL;ListNode* curr = *head;ListNode* next = NULL;for (int i = 1; i <= n; i++) {next = curr->next;curr->next = prev;prev = curr;curr = next;}*head = prev;return;}ListNode* prev = NULL;ListNode* curr = *head;for (int i = 1; i < m; i++) {prev = curr;curr = curr->next;}reverseBetween_turtle(&curr, 1, n - m + 1);if (prev != NULL) {prev->next = curr;} else {*head = curr;}
}// 打印链表
void printList(ListNode *head)
{while (head != NULL){printf("%d -> ", head->val);head = head->next;}printf("NULL\n");
}// 释放链表内存
void free_List(ListNode *head)
{while (head != NULL){ListNode *temp = head;head = head->next;free(temp);}
}// 主函数
int main()
{// 创建链表 1 -> 2 -> 3 -> 4 -> 5ListNode *head = createNode(1);head->next = createNode(2);head->next->next = createNode(3);head->next->next->next = createNode(4);head->next->next->next->next = createNode(5);printf("Original List: ");printList(head);// 反转第2个到第4个节点reverseBetween_turtle(&head, 2, 4);printf("Reversed List: ");printList(head);// 释放链表内存free_List(head);return 0;
}二、斐波那数列（C）
#include <stdio.h>int fun(int x)
{int sum = 0;if(x==0)return 0;if(x==1)return 1;sum=fun(x-1)+fun(x-2);return sum;
}int main()
{ int x=10;int i;for(i=0;i<x;i++)printf("%d\n",fun(i));
}三、猴子吃桃（C）
一只猴子第一天摘了n个桃，当即吃了一半又多吃了一个，第二天又吃了一半再多吃一个，直到第十天早上想吃时只剩下1个，问第一天摘了多少桃？
#include <stdio.h>//逆向思维
void fun()
{int i, m = 1;for (i = 1; i <= 9; i++){m = 2 * (m + 1);}printf("%d", m);
}int main()
{fun();return 0;
}四、水仙花数（C）
水仙花数（Narcissistic number），又称为自恋数、自幂数、阿姆斯壮数（Armstrong number），是指一个n位正整数，其各位数字的n次幂之和等于该数本身。对于三位数的水仙花数，我们需要找到一个数，它的每一位数字的立方和等于它本身。例如，153是一个水仙花数，因为 13+53+33=15313+53+33=153。
//打印100-999中所有的水仙花数
#include <stdio.h>void fun()
{int i, j, k;int sum;// 遍历所有的三位数for (i = 1; i < 10; i++){for (j = 0; j < 10; j++){for (k = 0; k < 10; k++){// 构造三位数int number = i * 100 + j * 10 + k;// 计算各位数字的立方和sum = i * i * i + j * j * j + k * k * k;// 判断是否为水仙花数if (number == sum){printf("%d\n", number);}}}}
}int main()
{fun();return 0;
}五、阶乘计算（C）
#include <stdio.h>float fun(int m, int n)
{float p1 = 1, p2 = 1, p3 = 1, p4;/*m的阶乘*/for (int i = 1; i <= m; i++)p1 *= i;/*n的阶乘*/for (int i = 1; i <= n; i++)p2 *= i;/*m-n的阶乘*/for (int i = 1; i <= m - n; i++)p3 *= i;p4 = p1 / (p2 * p3);return p4;
}int main()
{float ans = fun(10, 4);printf("结果:%f", ans);return 0;
}六、指针参数的使用
求数组中最大元素的下标，并输出存储的值。
在 C 语言中，当你想要一个函数修改某个变量的值，并且这个修改需要在函数调用后仍然有效，你需要传递该变量的地址（即指针）。这样，函数就可以通过解引用指针（使用 * 操作符）来修改原始变量的值。
使用指针 *k 的好处是，函数可以直接修改调用者提供的变量，而不需要返回额外的值。这样可以在不增加函数返回值复杂度的情况下，传递更多的信息。
#include <stdio.h>int fun(int *s, int t, int *k)
{int i;*k = 0; // 初始化*k为数组的第一个元素的下标for (i = 0; i < t; i++){if (s[*k] < s[i]){*k = i; // 找到更大的元素，更新*k为当前元素的下标}}return s[*k]; // 返回最大元素的值
}int main()
{int arr[] = {3, 5, 1, 4, 2}; // 示例数组int k = 0; // 用于存储最大元素的下标int max = fun(arr, 5, &k); // 调用函数，传入数组、数组大小和k的地址printf("最大元素是: %d, 下标是: %d\n", max, k); // 打印最大元素及其下标return 0;
}七、小球落地
一小球从100米高度自由落下，每次落地后反弹回原高度的一半再落下，求它在第十次落地时共经过多少米？第十次反弹多高？
#include <stdio.h>// 传入初始高度、反弹次数和储存最后一次的参数
double fun(double s, int n, double *h)
{double ans = s; // 总距离，初始为第一次下落的距离*h = s/2; // 第一次反弹的高度for (int i = 0; i < n; i++){ans = ans + 2 * *h; // 每次落地和反弹的总距离*h /= 2; // 更新下一次反弹的高度}return ans; // 返回最大元素的值
}int main()
{int n = 10; // 次数double s = 100; // 初始高度double h = 0; // 用于存储反弹高度double ans = fun(s, n, &h);printf("距離: %.5f, 第%d次反彈高度: %.5f\n", ans, n, h); // 打印最大元素及其下标return 0;
}八、常用排序算法
（1）冒泡排序（Bubble Sort）
通过对待排序序列从前向后（或从后向前），依次比较相邻元素的值，若发现逆序则交换，使值较大（或较小）的元素逐渐从前移向后（或从后移向前），就像水底的气泡一样逐渐向上冒。它的时间复杂度：平均和最坏情况都是O(n^2)，最好情况是O(n)（但这种情况很少出现）。冒泡排序是一种交换排序，冒泡排序是从第一个元素开始，相邻的两个数俩俩比较，若后面一个数大于（小于）前一个数则交换，一直到把每趟的最大（小）元素都排在末尾。下面以最大为例：
#include <stdio.h>void bubbleSort(int arr[], int n)
{int i, j, temp;for (i = 0; i < n-1; i++) { // 每次遍历都会将一个最大值移动到数组的末尾for (j = 0; j < n-i-1; j++) {if (arr[j] > arr[j+1]) // 交换元素{ temp = arr[j]; arr[j] = arr[j+1];arr[j+1] = temp;}}}
}void printArray(int arr[], int size) // 数组打印
{ for (int i = 0; i < size; i++) {printf("%d ", arr[i]);}printf("\n");
}// 函数实现
int main()
{int arr[] = {64, 34, 25, 12, 22, 11, 90};int n = sizeof(arr) / sizeof(arr[0]);printf("排序前的数组: \n");printArray(arr, n);bubbleSort(arr, n); //冒泡排序算法printf("排序后的数组: \n");printArray(arr, n);return 0;
}
（2）快速排序（Quick Sort）
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。他打时间复杂度：平均O(n log n)，最坏O(n^2)（但可以通过随机化等方式优化）。下面是算法实现：
#include <stdio.h>// 交换两个元素
void swap(int* a, int* b)
{int temp = *a;*a = *b;*b = temp;
}// 分区函数（左边小右边大），选择最后一个元素作为中心点
int partition(int arr[], int low, int high)
{int pivot = arr[high]; // 中心元素int i = (low - 1); // 小于中心点的元素的索引for (int j = low; j <= high - 1; j++) {// 如果当前元素小于或等于中心点if (arr[j] <= pivot) {i++; // 将小于中心点的元素放在正确位置swap(&arr[i], &arr[j]);}}swap(&arr[i + 1], &arr[high]); // 把中心点放到正确位置return (i + 1); // 返回中心位置
}// 快速排序主函数
void quickSort(int arr[], int low, int high)
{if (low < high) {// pi 是分区索引，arr[pi] 已经被放在了正确的位置int pi = partition(arr, low, high);// 分别对左右子数组进行快速排序quickSort(arr, low, pi - 1); // 左子数组quickSort(arr, pi + 1, high); // 右子数组}
}// 输出数组
void printArray(int arr[], int size) {for (int i = 0; i < size; i++) {printf("%d ", arr[i]);}printf("\n");
}int main() {int arr[] = {10, 7, 8, 9, 1, 5};int n = sizeof(arr) / sizeof(arr[0]);printf("排序前的数组: \n");printArray(arr, n);quickSort(arr, 0, n - 1);printf("排序后的数组: \n");printArray(arr, n);return 0;
}
（3）希尔排序（Shell's Sort）
称为缩小增量排序（Diminishing Increment Sort），是插入排序的一种更高效的改进版本，由美国计算机科学家Donald Shell于1959年提出。希尔排序通过将原始记录序列分割成若干个子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序，从而提高了排序效率。
希尔排序的基本思想是将待排序的数组元素按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。这种方法实质上是一种分组插入方法。
排序过程：确定增量：首先确定一个初始的增量（这个增量的选择对排序效率有很大影响），通常可以选择数组长度的一半作为初始增量。分组排序：根据当前增量将数组分成若干个子序列，每个子序列由下标差值为增量的元素组成。对每个子序列进行直接插入排序。减小增量：完成一轮排序后，减小增量值，继续对新的子序列进行排序。重复步骤：重复上述分组排序和减小增量的过程，直到增量为1，此时整个数组恰被分成一组，进行最后一次直接插入排序。
算法代码：
#include <stdio.h>// 希尔排序函数
void shellSort(int arr[], int n)
{// 开始时将增量设置为数组长度的一半for (int gap = n / 2; gap > 0; gap /= 2) {// 对每个子数组进行插入排序for (int i = gap; i < n; i++) {int temp = arr[i];int j;// 通过增量 gap 进行分组，并进行插入排序for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {arr[j] = arr[j - gap];}arr[j] = temp;}}
}// 输出数组
void printArray(int arr[], int size)
{for (int i = 0; i < size; i++) {printf("%d ", arr[i]);}printf("\n");
}int main()
{int arr[] = {12, 34, 54, 2, 3};int n = sizeof(arr) / sizeof(arr[0]);printf("排序前的数组: \n");printArray(arr, n);shellSort(arr, n);printf("排序后的数组: \n");printArray(arr, n);return 0;
}
（4）插入排序（Insertion Sort）
将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。
#include <stdio.h> // 插入排序函数
void insertionSort(int arr[], int n)
{ int i, key, j; for (i = 1; i < n; i++){ key = arr[i]; // 选择未排序序列的第一个元素作为关键字 j = i - 1; /* 将大于key的元素向后移动一位 */ while (j >= 0 && arr[j] > key) { arr[j + 1] = arr[j]; j = j - 1; } arr[j + 1] = key; // 插入key到正确的位置 }
} // 打印数组
void printArray(int arr[], int size)
{ int i; for (i = 0; i < size; i++) printf("%d ", arr[i]); printf("\n");
} // 主函数来测试上述代码
int main()
{ int arr[] = {12, 11, 13, 5, 6}; int n = sizeof(arr) / sizeof(arr[0]); insertionSort(arr, n); printf("Sorted array: \n"); printArray(arr, n); return 0;
}九、素数問題
素数（质数），就是仅能被自身和1整除的数字。
思路1：穷举法。这种方法涉及将一个整数 m 与从 2 到 m-1 之间的每一个整数相除，如果 m 不能被这些数中的任何一个整除，那么 m 就是一个素数。
思路2：优化的穷举法。这种方法简化了判断过程，只需将 m 与从 2 到 sqrt(m) 之间的每一个整数相除。如果 m 不能被这些数中的任何一个整除，那么 m 就是一个素数。这是因为如果 m 能被 2 到 m-1 之间的任何数整除，那么它的因子必定有一个小于或等于 sqrt(m)，另一个大于或等于 sqrt(m)。
1.1判斷一個數是否為素數。
#include <stdio.h>
#include <stdbool.h> // 引入布尔类型// 函数声明：判断一个数是否为素数
bool isPrime(int num);int main() {int number;printf("请输入一个整数：");scanf("%d", &number);// 调用函数并打印结果if (isPrime(number)) {printf("%d 是素数。\n", number);} else {printf("%d 不是素数。\n", number);}return 0;
}// 函数定义：判断一个数是否为素数
bool isPrime(int num) {if (num <= 1) {return false; // 小于等于1的数不是素数}if (num == 2) {return true; // 2是素数}if (num % 2 == 0) {return false; // 排除偶数}for (int i = 3; i * i <= num; i += 2) {if (num % i == 0) {return false; // 如果能被其他数整除，则不是素数}}return true; // 如果没有找到除数，则为素数
}1.2 判斷一個數是否為素數。
#include <stdio.h>
#include <math.h>int main() {int m; // 输入的整数int i; // 循环变量int k; // m 的平方根printf("输入一个整数：");scanf("%d", &m);// 求平方根，注意 sqrt() 的参数为 double 类型，这里要强制转换 m 的类型k = (int)sqrt((double)m);for (i = 2; i <= k; i++) {if (m % i == 0) {break; // 如果能被整除，跳出循环}}// 如果完成所有循环，那么 m 为素数if (i > k) {printf("%d 是素数。\n", m);} else {printf("%d 不是素数。\n", m);}return 0;
}2.求100到200之间的所有素数并输出。
#include<stdio.h>int main()
{int a, b, flag;for (a = 100; a <= 200; a++) //得到100到200间的所有数字{flag = 0; //先假设a为素数 for (b = 2; b < a; b++) //注意，不要忘了自身也能被整除！{if (a % b == 0){flag = 1; //若出现不能整除的情况，则令flag为1 break;}} //标记变量——flagif (0 == flag)printf("%d ", a);}return 0;
}
十、双素数问题
一个正整数是素数当且仅当它除了1和自身以外没有其他因子。现在我们定义双素数：一个正整数是双素数当且仅当它本身是个素数，并且将他的十进制表示反转后得到数不等于它自身且也是个素数。如13就是一个双素数，因为13和31不相等且都是素数。现给出一个整数k，你需要找到第k小的双素数。
#include <stdio.h>
#include <math.h>// 检查一个数是否是素数
int isPrime(int n){if(n==1) return 0;int flag = 1;int k = (int)sqrt((double)n);for(int i=2; i<k; i++){if(n % i == 0){flag = 0;break;}}return flag;
}// 反转一个数字
int ReverseNum(int num){int reversed = 0;while (num > 0) {reversed = reversed*10 + num%10;num /= 10;}return reversed;
}int main() {int n;int count = 0, num = 10;scanf("%d",&n);while (1){if(isPrime(num) && isPrime(ReverseNum(num)) && n != ReverseNum(num)){count++;if(count == n){printf("%d",num);return 0;}}num++;}
}十一、不排序找第K小的数
快速选择算法。
/** @Author: Gui林* @Date: 2024-11-06 16:20:15* @function: 不排序找第K小的数* @FilePath: \test\c\cpp3.c* @LastEditTime: 2024-11-06 17:10:52*/
#include <stdio.h>
#include <stdlib.h>// 交换两个数
void swap(int *a, int *b){int temp = *a;*a = *b;*b = temp;
}// 分区函数，将数组分为两部分，左边都比基准小，右边比基准大
int partition(int arr[], int left, int right){int pivot = arr[right];int i = left;for (int j = left; j < right; j++){if (arr[j] < pivot){swap(&arr[i], &arr[j]);i++;}}swap(&arr[i], &arr[right]);return i;
}int quickSelect(int arr[], int left, int right, int k){if (left == right){return arr[left];}int pivotIndex = partition(arr, left, right);if (k == pivotIndex) return arr[k];else if (k < pivotIndex) return quickSelect(arr, left, pivotIndex - 1, k);else return quickSelect(arr, pivotIndex + 1, right, k);
}int main()
{int arr[] = {12, 3, 5, 7, 4, 19, 26, 0, 12 ,3}; // 示例数组int n = sizeof(arr) / sizeof(arr[0]);int k = 4; // 要找到第K小的数int result = quickSelect(arr, 0, n-1, k-1); // k-1因为数组索引从0开始printf("The %d smallest number is: %d\n", k, result);return 0;
}十二、 判断括号是否匹配
定义了一个栈来存储遇到的开括号，每当遇到一个闭括号时，就检查栈顶的开括号是否与之匹配。如果匹配，就将栈顶元素出栈；如果不匹配或者栈为空，则说明括号不匹配。最后，如果字符串遍历完成后栈为空，则说明所有括号都匹配，否则不匹配。
栈（Stack）是一种重要的数据结构，它遵循后进先出（Last In First Out，LIFO）的原则。这意味着最后被添加到栈中的元素将是第一个被移除的。栈的两个主要操作是“入栈”（push）和“出栈”（pop）。入栈是将元素添加到栈顶，而出栈是从栈顶移除元素。
出栈操作只是改变了栈顶指针的位置，而栈中的值仍然存在于数组中。这种设计使得栈操作非常高效，因为不需要频繁地移动数组中的元素，只需要维护一个指向栈顶的指针即可。
1.C语言实现
/** @Author: Gui林* @Date: 2024-11-06 15:56:29* @function: 判断括号是否匹配* @FilePath: \test\c\cpp2.c* @LastEditTime: 2024-11-06 17:50:12*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>// 定义栈的最大容量
#define MAX_SIZE 100// 栈的结构体
typedef struct {char arr[MAX_SIZE];int top;
} Stack;// 初始化栈
void InitStack(Stack *s) {s->top = -1;
}// 判断栈是否为空
int IsEmpty(Stack *s) {return s->top == -1;
}// 入栈操作
void Push(Stack *s, char c) {if (s->top < MAX_SIZE - 1) {s->arr[++s->top] = c;}
}// 出栈操作
char Pop(Stack *s) {if (!IsEmpty(s)) {return s->arr[s->top--];}return '\0'; // 如果栈为空，返回空字符
}// 查看栈顶元素
char Stack_Peek(Stack *s) {if (!IsEmpty(s)) {return s->arr[s->top];}return '\0'; // 如果栈为空，返回空字符
}// 判断括号是否匹配
int IsMatch(char *str) {Stack s;InitStack(&s);for (int i = 0; str[i] != '\0'; i++) {char c = str[i];switch (c) {case '(':case '[':case '{': Push(&s, c); break;case ')':if (IsEmpty(&s) || Stack_Peek(&s) != '(') {return 0;}Pop(&s);break;case ']':if (IsEmpty(&s) || Stack_Peek(&s) != '[') {return 0;}Pop(&s);break;case '}':if (IsEmpty(&s) || Stack_Peek(&s) != '{') {return 0;}Pop(&s);break;default: break; // 忽略非括号字符}}return IsEmpty(&s); // 如果栈为空，则匹配
}int main() {char str[] = "{[()()]"; // 测试字符串if (IsMatch(str)) {printf("The brackets are matched.\n");} else {printf("The brackets are not matched.\n");}return 0;
}2.Python实现
在Python中，字典（Dictionary）是一种内置的数据结构，它以键值对（key-value pairs）的形式存储数据。字典的每个键（key）都唯一地映射到一个值（value）。
'''
Author: Gui林
Date: 2024-11-06 16:00:10
function: 判断括号是否匹配
FilePath: \test\python\python2.py
LastEditTime: 2024-11-06 16:00:32
'''def is_matched(expression):# 使用字典来定义匹配的括号对matching_brackets = {')': '(', ']': '[', '}': '{'}# 使用列表作为栈stack = []for char in expression:if char in matching_brackets.values():# 如果是开括号，压入栈stack.append(char)elif char in matching_brackets.keys():# 如果是闭括号，检查栈顶元素if not stack or stack.pop() != matching_brackets[char]:return False# 忽略非括号字符# 如果栈为空，则所有括号匹配return not stack# 测试代码
expressions = ["{[()()]}", "{[(])}", "{[(]", "({[]})}", "((()))"]
for expr in expressions:print(f"{expr}: {is_matched(expr)}")十三、
