菜鸟502的博客

#include <iostream>using namespace std;template<class T>void bubble_sort(T *arr, int len){ T tmp; for(int i = 0; i < len - 1; ++ i) { for(int j = 0; j < len - 1 - i; ++ j)

#include <iostream>#include <cmath>using namespace std;#define N 8bool ground[N + 1][N + 1] = {0};bool is_legal(bool ground[N + 1][N + 1], const int &i, const int &j){ for (int m = 1; m <= i - 1;

基于辗转相除法的最大公约数和最小公倍数的算法实现#include<iostream>#include <string>using namespace std;int gcd(int a, int b){ if(a < b) swap(a, b); while(b) { int tmp = a % b; a = b;

常用八个排序算法性能比较

在一个字符串中查找一个子字符串有很多方法，最简单容易想到的算法便穷举，但这样的情况下算法复杂度为O(m * n)。 而KMP是一种最常见的改进算法，它可以在匹配过程中失配的情况下，有效地多往后面跳几个字符，加快匹配速度。 KMP算法中有个数组，叫做前缀数组，也有的叫next数组，每一个子串有一个固定的next数组，它记录着字符串匹配过程中失配情况下可以向前多跳几个字符，当然它描述的也是子串的对称

链式存储无向图的基本操作

无向图的邻接矩阵基本操作

题目来源： https://leetcode.com/problems/binary-tree-preorder-traversal/ https://leetcode.com/problems/binary-tree-inorder-traversal/ struct TreeNode { int val; TreeNode *left; TreeNode *ri

二叉树链式存储结构typedef struct BiTNode{ char data; BiTNode *lchild, *rchild;} BiTNode, *BiTree;二叉树创建（递归）void create_bitree(BiTree &T){ char value; cin >> value; if(value == '#')

#include <iostream>using namespace std;template <class Type>Type max(Type arr[], int len){ if(len < 1) return -99999; Type ret = arr[0]; for(int i = 1; i < len; ++ i) {

# include <iostream>using namespace std;void my_qsort(int arr[], int, int); int main() { int n; cin>>n; int *arr = new int[n]; for(int i = 0;i < n; ++i) cin >> arr[i]; m

本文以最大为3位数字为例，并可以对负数进行排序#include<iostream>using namespace std;//获取第d+1位的数字//int get_digit(int x,int d) { int a[] = {1, 10, 100}; return (abs(x) / a[d]) % 10; } void lsd_sort(int ar

#include <iostream>using namespace std;template<typename T>void heapify(T *arry,int size,int element, bool dec){ int lchild=element*2+1,rchild=lchild+1;//左右子树 if(dec) { while(rchild<

#include <iostream>using namespace std;template <class T>void shell_sort(T *a, int n) { int j, gap; for (gap = n / 2; gap > 0; gap /= 2) { //从数组第gap个元素开始 for (j =

#include <iostream>using namespace std;template<class T>void merge(T *arr, int p, int q, int r){ int i, k; int s1 = p, e1 = q, s2 = q + 1, e2 = r; T *temp = new T[r - p + 1]; k = 0;

#include <iostream>using namespace std;template<class T>void insert_sort(T *arr, int len){ T tmp; int curPos; for(int i = 1; i < len; ++ i) { tmp = arr[i]; curPos = i

#include <iostream>using namespace std;template<class T>void select_sort(T *arr, int len){ T tmp; int curPos; for(int i = 0; i < len - 1; ++ i) { tmp = arr[i]; curPos

#include <iostream>using namespace std;template<class T>void bubble_sort(T *arr, int len){ T tmp; int tail = len - 1; for(int i = 0; i < tail; ) { //小的排到前面 for(int j

动态规划分为四个步骤： 1.判断问题是否具有最优子结构 这里以LCS为例，X={x1,x2,…,xi}；Y={y1,y2,…,yj}。最长公共子序列Z={z1,z2,…,zk}； ①如果xi=yj，那么zk=xi=yj，且Zk-1是序列Xi-1和Yj-1的LCS； ②如果xi≠yj，那么zk≠xi；且Zk是序列Xi-1和Yj的LCS； ③如果xi≠yj，那么zk≠yj；且Zk是序列Xi和Y