weixin_43086349的博客

#include<iostream>#include<vector>using namespace std;vector<vector<int>> vec;void backtrace(vector<int>& nums,vector<int>& path, int pos){ vec.push_back(path); for(int i=pos;i<nums.size();i++) { .

//函数接口：char* mystrstr(char* str1,char* str2)//解释：//在字符串str1中查找第一次出现str2的位置//如果找到匹配的字符串，返回第一次匹配字符串的指针//否则，返回NULL#include<isotream>using namespace std;char* mystrstr(char* str1,char* str2){ char* src,*sub; if(str1==NULL || str2==NULL) {

//向循环有序链表插入一个值//……struct ListNode{ int val; ListNode* next; ListNode(int x):val(x),next(NULL){}};ListNode* insertNodeToList(ListNode* LNode,ListNode* pNode){ //1.循环链表为空，新插入节点，首尾相连 if(LNode==NULL) { pNode->next=pNode; return PNode; }

//把数组分为两部分//一部分为已排列，另一部分为未排列//将未排列部分元素插入已排列部分//回溯，找出所有可能的答案//……void backtrace(vector<vector<int>>& ans,vector<int>& vec,int first, int len){ if(first==len) { ans.push_back(vec); return; } for(int i=first;i<len;i.

//向单向有序链表中插入一个节点，保证其有序性不变struct ListNode{ int val; ListNode* next; ListNode(int x):val(x),next(NULL){}};ListNode* insertToList(ListNode* head,ListNode* pNode){ if(head==NULL || pNode==NULL) return NULL; ListNode* dumm=new ListNode(); dumm-&gt

质数：只能被1和它本身整除的数。#include<iostream>using namespace std;int main(){ int n; cin>>n; for(int i=2;i<=n;i++) { for(int j=2;j<=i;j++) { if(i%j==0 && i!=j) break; if(i%j==0 && i==j) cout<<i<<endl;

//由题意得，高度平衡的二叉搜索树左右子树高度差不超过1.//因此上，让根节点保证在链表序列的中间位置，此时左右子树得高度差不超过1.//采用递归的方式.struct ListNode{ int val; ListNode* next; ListNode(int x):val(x),next(NULL){}};struct TreeNode{ int val; TreeNode* left; TreeNode* right; TreeNode(int x):val(x),l.

//由于时间复杂度要求，因此不能用常见排序算法去处理//借助set的性质，去重和排序class Solution{public: int longestSequence(vector<int>& vec) { set<int> s; for(int elem:vec) s.insert(elem); //遍历 int longest=0; int cnt=1; for(auto e:s) { if(s.find(e+1)!=.

//可以从前面的任何一层跳到当前层//因此是前n-1层跳法的总和………………………………int jumpFloor(int n){ vector<int> step(n+1,0); step[0]=step[1]=1; for(int i=2;i<=n;i++) { for(int j=0;j<i;j++) { step[i]+=step[j]; } } return step.back();}...

将str2指向的字符串拷贝到str1中去，并返回指向字符串str1的指针。//首先要保证str1有一段可以容纳str2字符串的内存空间，及str1的空间足够大,最少可以存放str2(包括末尾结束符).//将str2中的字符拷贝到str1中的对应位置，采用一个循环来实现//循环结束标志为str2遇到'\0'；#include<iostream>#include<string>using namespace std;char *mystrcpy(char* str1,

//本题的关键在于“每个节点”的左右两个子树高度差的绝对值为1.//因此，要判断“每个节点”的左右子树.struct TreeNode{ int val; TreeNode* left; TreeNode* right; TreeNode(int x):val(x),left(NULL),right(NULL){}};class Solution{public: //定义一个求树高度的方法 //递归 int treeHeight(TreeNode* root) { i.

如果字符串str1大于str2，则返回1，如果字符串str1小于str2，则返回-1，如果字符串str1等于str2，则返回0。#include<iostream>#include<string>using namespace std;int mystrcmp(const char* str1,const char* str2){ if(*str1==NULL || *str2==NULL) { cout<<"INPUT ERROR!"<&lt

//最长上升子序列，动态规划//先找出每一位置i的左侧的最长上升子序列的长度center_left[i],每一位置i的最长上升子序列的长度的取值为其左侧比它小的所有位置的最长上升子序列长度中的最大值+1；//再找出每一位置i的右侧的最长下降子序列的长度center_right[i],每一位置i的最长下降子序列的长度的取值为其右侧比他小的所有位置的最长下降子序列长度中的最大值+1；//最后求出每个位置的满足要求的最长序列长度为center_left[i]+center_right[i]-1（i位置多算.

#include<iostream>#include<string>using namespace std;int main(){ string str; while(cin>>str) { pair<int,int> point(0,0); int len=str.size(); int start=0; size_t found=str.find_first_of(';'); while(found!=string:.

#include<iostream>#include<string>#include<vector>#include<ctype.h>#include<algorithm>using namespace std;bool charSort(char& chr1, char& chr2){ char ch1=tolower(chr1); char ch2=tolower(chr2); return ch1&g.

#include<iostream>#define SIZE 100;using namespace std;class Queue{private: int arr[SIZE]; int head; int tail;public: Queue() { head=0; tail=0; } bool isFull() { return (tail+1)% SIZE==head; } bool isEmpty() { return head==t

//说明：//1.所有的节点值都是唯一的//2.p,q为不同节点且均存在于二叉树中struct TreeNode{ int val; TreeNode* left; TreeNode* right; TreeNode(int x):val(x),left(NULL),right(NULL){}};class solution{ TreeNode* lowestCommonAncestor(TreeNode* root,int p,int q) { //递归 if(!r.

struct TreeNode{ int val; TreeNode* left; TreeNode* right; TreeNode(int x):val(x),left(NULL),right(NULL){}};TreeNode* built(vector<int>& preorder,vector<int>& inorder){ if(preorder.size()==0 || inorder.size()==0 || preorder.s.

LFU算法：（Least Frequently Used），对每一个数据的访问频次作一记录，数据的访问次数越多，节点访问次数越大。*新插入的数据访问频次为1；*相同频次的数据按时间排序，后插入的在前面；*当需要淘汰数据时，会从尾部开始淘汰，即访问频次从小到大...

//归并排序算法：//1.拆分//2.合并//与快排算法的不同点：//1.归并排序不是求子问题的解，而在于合并子问题的解//2.归并需要借助额外的内存空间//3.归并时间复杂度最好最坏均是O(NlogN)#include<iostream>#include<vector>using namespace std;void merge_sort(vector<int>& vec,int begin,int end);//拆分void mer

//前序遍历struct TreeNode{ int val; TreeNode* left; TreeNode* right; TreeNode():val(0),left(NULL),right(NULL){} TreeNode(int x):val(x),left(NULL),right(NULL){} TreeNode(int x,TreeNode* left,TreeNode* right):val(x),left(left),right(right){}};class s.

#include<iostream>#include<vector>#include<algorithm>using namespace std;void select_sort(vector<int>& nums);int main(){ vector<int> ans={0,3,5,2,9,8,6,4,7,1}; select_sort(ans); for(int elem:ans) cout<<el

#include<iostream>#include<vector>#include<algorithm>using namespace std;void QuickSort(vector<int>& nums,int begin,int end){ if(begin>=end) return; int mid=begin+(end-begin)/2;//增加随机性 swap(nums[mid],nums[end]);

#include<iostream>#include<string>using namespace std;int main(){ string s="abc"; string t="ahbgdc"; int s_len=s.size(); int t_len=t.size(); if(s_len>t_len) return false; int i=0,j=0,cnt=0; while(i<s_len && j<t.

LRU(Least Recently Used Algorithm)LRU算法的高效执行（插入、查找、删除）。插入、删除（链表）查找（哈希表）因此采用哈希表和链表相结合的方式实现LRU算法。#include<iostream>#include<unordered_map>//包含include<list>using namespace std;class cacheLRU{private: struct Node { int key;

给定一个链表和一个特定的值x，对链表进行分割，使得所有小于x的节点都在大于或等于x的节点之前，且新的链表应保留两个分区中节点的原始相对位置不变。示例：输入: head = 1->4->3->2->5->2, x = 3输出: 1->2->2->4->3->5//双链表//遍历原始链表//将小的节点放在一个链表中，大于等于的节点放在另外一个节点中//将两个链表拼接struct ListNode{ int val; ListNo

希尔排序的提出原因：希尔排序是对插入排序的优化。假设在插入排序中，有个最小元素位于排序序列最末尾，那么在排序过程中需要将该最小值一步一步地移动到序列的第一个位置，此时复杂度太高O(n^2)，为了避免该类情况发生，给其设置了一个增量让其大步移动，优化其效率，此即为希尔排序。希尔排序的基本思想：先取小于n的整数d1作为第一个增量，把全部记录分组。所有距离为d1倍数的记录放在同一组中，先在各组内进行直接插入排序；然后，去第二个增量d2<d1重复上述的分组和排序，直到所取的增量dt=1(dt<dt

思路：最长公共子序列、动态规划#include<iostream>#include<vector>#include<algorithm>using namespace std;int unintersect_line(vector<int>& nums1,vector<int>& nums2){ int len1=nums1.size(); int len2=nums2.size(); vector<vec

原理：前部分有序，后部分无序，每次将无须部分的第一个数字插入到有序部分的合适位置，有序部分长度加1，无序部分长度减1。时间复杂度O(n^2)，空间复杂度O(1)，稳定排序。#include<iostream>#include<vector>#include<algorithm>using namespace std;void insert_sort(vector<int>& nums){ int len=nums.size();

C＋＋排序算法之冒泡排序：思想：每次遍历，将相邻元素两两比较，前者小，后者大，直至将最大的元素放置在数组尾部，数组长度减１，即未排序部分的长度。稳定排序，时间复杂度O(n^2)，空间复杂度O(1)。#include<iostream>#include<vector>#include<algorithm>using namespace std;void bubble_sort(vector<int>& nums){ int len=

正整数A，B的最小公倍数是指能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。#include<iostream>using namespace std;int main(){ //最小公倍数=两数之积/最大公约数； int A，B，p; cin>>A>>B; p=A*B; if(A<B) swap(A,B) while(B!=0) { int temp; temp=A%B; A=B; B=temp;

不使用库函数，求一个数字的立方根，保留小数点后一位。//二分法#include<iostream>#include<iomanip>using namesapce std;double getCubeRoot(double x){ if(x==-1 || x==0 || x==1) return x; int flag=0; double mid; double low=1.0; double high=x; if(x<0) { flag=-

给定一个包含0和1的非空二维数组grid,一个岛屿是由一些相邻的1（代表陆地）构成的组合，这里的相邻要求两个1必须在水平或者竖直方向上相邻，假设grid的四个边缘都被0（代表水）包围着。 找到grid中岛屿的最大面积，如果没有岛屿，则返回面积0。//深度优先搜索int dfs(vector<vector<int>>& grid,int cur_i,int cur_j){ if(cur_i<0 || cur_j<0 || cur_i>grid.siz

给定一个字符串数组，求改数组字符串的最长公共前缀，如果不存在最长公共前缀，返回空字符串“”；示例：输入：[“flower”,“flow”,“flight”]输出：“fl”//substr(pos,len); pos起始位置、len长度string LongestCommonPrefix(vector<string>& strs){ if(strs.empty()) return ""; string ans=strs[0]; int len=strs[0].size(

题目：给定两个用链表表示的整数，每一个节点包含一个数位。这些数式反向存放的，也就是个位排在链表首部，编写函数对这两个整数求和，并用链表形式返回结果。示例：输入：（7->1->6）和(5->9->2)即617+295输出：2->1->9 即912struct ListNode{ int val; ListNode* next; ListNode(int x):val(x),next(NULL){}};class Solution{public:

题：一个只包含0和1的阵列，找到1的组的个数，每个组的定义是横向和纵向相邻的值都为1。解法：深度优先搜索class Solution{public: int Group_one_num(vector<int>& nums) { int ans=0; if(nums.empty()) return ans; for(int i=0;i<nums.size();i++) { for(int j=0;j<nums[0].size();j++)

给定一个二叉搜索树，判断其是否是一个有效的二叉搜索树。假设一个二叉搜索树具有如下特征：①节点的左子树只包含小于当前节点的数②节点的右子树只包含大于当前节点的数③所有左子树和右子树自身必须是二叉搜索树struct TreeNode{ int val; TreeNode* left; TreeNode* right; TreeNode(int x):val(...

给定一个非负数数组，最初位于数组的第一个位置，数组中的每个元素代表在该位置可以跳跃的最大长度，你的目标是使用最少的跳跃粗疏到达数组的最后一个位置。例：输入[2,3,1,1,4]输出2。第一步 2-3第二步 3-4class Solution{ public: int jump(vector<int>& nums) { ...

给定一个整数数组，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。class Solution{public: int maxSumOfVector(vector<int>& nums) { int ans=0,maxAns=nums[0]; for(int e:nums) { ...

移除未排序链表中的重复节点，保留最开始出现的节点。struct ListNode{ int val; ListNode* next; ListNode(int x):val(x),next(NULL){}};class Solution{public: ListNode* removeDuplicateNodes(ListNode* head) ...