Irean_Lau的专栏

/* 字符串匹配:> BM->KMP*/int func(char*s, char*p){ int i = 0; int j = 0; while (i < strlen(s)) { j = 0; while (s[i] == p[j] && j < strlen(p)) { j++

/* 30:> 最小的k个数 1) 用数组的第k个数，进行基于快排的partion ： O（n）,但要修改数组 2）最小堆，（multiset）O（nlogk）,无需修改数组,适合数据量大，而k小的时候 p169*/int Partion(int ar[], int start, int end)//end->len{ int left = start;

/* 连续子数组最大和 {1，-2，3，10，-4，7，2，-5} 分析数组规律,两个变量（MaxSibSum,SibSum）解决问题*/bool g_InvalidInput = false;//判断非法输入int FindMaxSibSumArray(int ar[], int len){ if (ar == NULL || len <= 0) {

/* 33: > 把数组排列成最小的数 {3,32,321} -> 321323 考虑大数问题，开辟 指针数组（str数组） ，每个元素的字符串，存放对应位置的整数（sprintf） 对整个 str数组 进行qsort（需要定制compare） compare: 对于M，N 拼接，比较MN和NM的大小。*/const int g_MaxNumLen =

/* 34:> 丑数（因子只含2，3，5 ： 6，8是，14不是） 习惯第一个丑数为 1*/int minNum(int val1, int val2, int val3){ int tmp = val1 < val2 ? val1 : val2; return tmp < val3 ? tmp : val3;}int GetUglyNum(int

/* 36:> 数组中的逆序对 （7，4）前比后大 叫逆序对*/int InversePairsCore(int data[], int copy[], int start, int end);int InversePairs(int data[],int len){ if (data == NULL || len < 0) return 0; i

/* 37：>两个链表公共节点 首先 获取两个链表长度，差值为x，长的先走x步；两个同时走，第一个公共节点即是 O(m+n)*/struct ListNode{ int m_nKey; ListNode* m_pNext; ListNode(int val, ListNode* pNode) :m_nKey(val), m_pNext(

/* 38 :>数字在排序数组中出现的次数 {1,2,3,3,3,3,4,5} 3出现4次 遍历一遍O(n) 更优解： 归并查找第一个3，位置first；最后一个3，位置last 个数 last-first+1*/int GetNumFirstPos(int* ar,int len,int start,int end,int k);int

/* 39:> 二叉树的深度*/int Depth(BinTree* pRoot){ if (pRoot == NULL) return 0; int nLeft = Depth(pRoot->m_pLeft); int nRight = Depth(pRoot->m_pRight); return (nLeft > nRight) ? (

/* 40:> 数组中只出现一次的数（2个）（其他都出现2次） 时间：O(n)，空间O(1) 异或 {2,4,3,6,3,2,5,5} 第一次异或 即4^6->0010 用0010把数组分成两部分{2,3,6,2,3},{4,5,5}*/int _res(int ar[], int len){ int res = 0; for (

/* 41：和为s的两个数 ； 和为s的连续正整数序列 {1，2，4，7，11，15} 求和为15的两个数(头尾指针)*/bool FindTwoNumOfSum(int ar[], int len, int sum, int *num1, int *num2){ bool flag = false; if (ar == NULL || len <= 0

/* 42:> 翻转句子 ； 左旋字符串 i am student -> student am i (整体翻转，局部翻转)*/void Reserve(char* pBegin, char* pEnd){ if (pBegin == NULL || pEnd == NULL || pBegin+1==pEnd) return; while (pB

/* 44:> 扑克牌的顺子 判断一个数组的所有元素是不是顺子，0可以代表任何数 {1,5,4,0,3}能不能组成顺子 1.先排序： {0,1,3,4,5} 2.统计0的个数numofZero 3.统计空缺的个数numofGap : 1,3 空缺 ：3-1-1 == 1个 4.将空缺位置用0填充，看够不够 return (numo

/* 45:> 约瑟夫环*///数学解法int LastLive(size_t total, size_t key){ if (total < 1 || key < 1) return -1; int last = 0; for (int i = 2; i <= total; ++i) last = (last + key) % i

/* 46:> 求和1+2+3+....n 不能使用for while if else switch case 三目运算符*/class Sum{public: Sum() { ++N; sum += N; } static void set() { N = 0; su

/* 29：> 数组中超过一半的数 排序 mid位置既是 [num][times]组合*///避免最多的数只达到一般： 比如134个数，中最多出现的数频率67bool check(vector<int>gifts, int n, int num){ int count = 0; for (int i = 0; i < n; ++i) if

/* 28:> 字符串全排列 递归，子问题求解 将首字母和后面每一个字母交换，对处理后的序列做相同处理（str+1）*/void perm(char* pStr, char* pBegin);void perm(char* pStr){ if (pStr == NULL) return; perm(pStr,pStr);}void

/* 重建二叉树 pre 1,2,4,7,3,5,6,8 in 4,7,2,1,5,3,8,6*/struct BinTree{ int m_nValue; BinTree* m_pLeft; BinTree* m_pRight; BinTree(int x) : m_nValue(x), m_pLeft(NULL),

/* 旋转数组最小值 {3,4,5,1,2}*/int Min(int* numbers, int length){ if (numbers == NULL || length <= 0) exit(1); int left = 0; int right = length - 1; int mid = left; while

/* 数（可能浮点）的整数次方 a^n=a^(n/2) * a^(n/2) : n偶数 a^n=a^(n/2) * a^(n/2) * n : n偶数*/double func(double base, unsigned exp)//这里只考虑 指数不为负数，负数 用1除即可{ if (base == 1 || exp==0)

/* 12.打印1到最大的n位数 ,给 3 ,打出1,2,3,.....999 数字转换成字符集合的全排列问题，前面为0的不打出来 解决了n比较大 溢出的问题*///098->98void printnum(char* num){ int flag = false;//默认开头有‘0’ int len = strlen(num); for (in

/* 1,2,3,4,5 -》 奇数在前 偶数在后 */ void func(int* pdata, unsigned int length) { if (pdata == NULL || length <= 0) return;int* left = pdata;int* right = pdata + length - 1;while (

/* 19:> 二叉树的镜像*/void MirrorTree(BinTree*& pNode){ if (pNode == NULL) return; if (pNode->m_pLeft == NULL && pNode->m_pRight == NULL) return; BinTree* pTmp=pNode->m_pLef

/* abbcad 找第一个不重复(重复)的*/char findFirstNoRepeat(string A, int n) { // write code here vector<int> array(256, 0); for (int i = 0; i < n; ++i) array[(int)(A[i] - '0')]++; for

/* 20 :> 顺时针打印数组*/vector<int> printMatrix(vector<vector<int> > matrix) { vector<int>res; res.clear(); int row = matrix.size();//行数 int col = matrix[0].size();//列数 int circle =

/* 21:> 包含min的栈*/#include <stack>template<class T>class MinStack{public: void m_push(const T& val) { m_data.push(val); if (m_min.size() == 0 || val < m_min.top())

/* 22:> 栈的弹出顺序*/bool IsPopOrder(vector<int> pushV, vector<int> popV) { if (pushV.size() == 0) return false; vector<int> stack; for (int i = 0, j = 0; i < pushV.size();) { stack

/* 24:> BST的后序遍历*/bool judge(int ar[], int len){ if (ar == NULL || len <= 0) return false; int root = ar[len - 1]; int i = 0; for (; i < len-1; ++i) if(ar[i]>root)

/* 25:> 二叉树中和为某一定值的路径 递归;栈保留序列(但为了打印完整，使用vector)*/void FindPath(BinTree* pRoot, int val, vector<int> path, int cursum){ cursum += pRoot->m_nValue; path.push_back(pRoot->m_nValue);

/* 26:> 复杂链表的复制 三步走： 1：A->B >> A->A`->B->B` 复制next链接 2：复制 Sibling链接 3：拆分链表 ，返回cloneList*/struct ComplexListNode{ int m_value; ComplexListNode* m_pN

/* 27:> 二叉搜索树 转 有序双向链表 左孩子指向前驱，右孩子指向后继 递归，动态规划*/BinTree* First(BinTree* pRoot){ if (pRoot == NULL) return NULL; BinTree* pF = pRoot; while (pF->m_pLeft) { p

/* 18 判断树的子结构：*/bool DoseTree1HasTree2(BinTree* root1, BinTree* root2){ if (root2 == NULL) return true; if (root1 == NULL) return false; if (root1->m_nValue == root2-