- 链表倒转 leetcode-206
- 连续子数组最大和问题(和最大的连续子序列的和) leetcode-53
- 输出字符串中最长的回文子串长度？ leetcode-5
- 一个字符串,求最长无重复子串的长度？ leetcode-3
- 最长递增子序列 leetcode-300
- 反转一个字符串。。。。。。（手写代码） leetcode-344
- 数组中存在一个大于n/2次的数，如何以最优方法查找它？LeetCode 169 \ 229
- 一个字符串中{} [ ] ()匹配问题 LeetCode 20
- 一个数组，只有一个数字出现奇数次，其余数字出现偶数次 LeetCode 136
- 给定一个ip地址，编码使得ip和32位整数呈双射关系 LeetCode 93
- 求一个数组逆序对的个数 LeetCode 629
- 1个32位整数，计算二进制格式下有多少个1 LeetCode 191
- 最小生成树与并查集 leetcode684，685， 721
- 比较两二叉树是否相同（手写代码）LeetCode 100
- 手写判断大小端的代码
- 单链表找倒数第n个节点 LeetCode 19
- 把一颗二叉树原地变成一个双向链表？ 114
- 判断一个无符号的整数是不是2的n次方？ 231
- int atoi(char *str)？ 8
- 栈的getmin()操作 O（1） 155
- 用栈实现队列，用队列实现栈？232 225
- 实现strstr函数 28
- 整数a和b，求a的b次方的最后三位数
- 算法题：将字符串转换成人民币大写（半小时后发邮箱）
- 如何删除map中的奇数节点
- 恢复翻转数组
- 二分法
- 排序
- 手写String
- memcpy函数的实现
- strcpy函数的实现
- BST的第K小的节点 230
- 判断链表是否有环，如果有，返回环的入口节点；求环的长度 141
- 求一个数组逆序对的个数 629
- 翻转数组和恢复翻转数组
- 删除单链表中间节点
- 判断两个单链表是否相交
- r行c列的0,1数组，找到最大的全为1的正方形？
- 连续子数组最大和问题(和最大的连续子序列的和)
- excel中，标志列的如AA,AZZ ,BS，求这些列到底是第几列
- 二叉树两个节点的最近公共祖先
- 去掉字符串中的空格字符
- 删除字符串开始和结尾处的空格，并将中间的多个连续的空格合并成一个
- char *s1, const char *s2，删除s1中s2出现过的字符
- 单链表判环
- 判断一个数是不是回文数
- 求一个集合的所有子集，递归实现，非递归实现
- 旋转有序数组的二分查找
- 删除数组中的重复元素
- 实现一个计算器计算简单的表达式字符串
- memcopy和memove
- 微信小程序团队一共有 n 名成员，决定出去秋游，在海边遇到出租摩托艇的杰克马
- 给定一个二叉树，节点值为0-9， LeetCode 129
- 写一个二叉树翻转，然后写个测试
- trcpy安全性，如何实现安全，strnpy,写一下并测试，
- 写sql语句(A表存储有每个电话号码当月通话记录，表B是电话号码集合，求表B每个号码通话次数)
- 如何设计一个好的字符串hash函数
- 两字符串最长公共子串， 最长公共子序列
- 打印二叉树每层最右边的节点 层序遍历 LeetCode 199
- 顺时针回形打印矩阵的元素 LeetCode 54
- 判断在一个矩阵中是否存在一条包含某字符串所有字符的路径 LeetCode 79
- 3sum 数组中三数之和为0的所有三元组 leetcode 15
- 判断一个字符串是不是两个有序的字符串交错组成的。 Leetcode 97
- 编程题：递增数组中找两个数和为某个固定值。设计测试用例 Leetcode 1
- 给你一个数组和数组元素的个数，求平均值。
- 两个非常大的数相加 Leetcode 415
- 手写下单例模式？
- 链表倒转
从尾到头打印链表（使用栈或者使用递归）
链表倒转
typedef struct ListNode
{
int data;
ListNode *next;
};
ListNode* reverseList1(ListNode *head)
{
if (head == NULL)
return head;
ListNode* dummy = new ListNode;
dummy->data = -1;
dummy->next = head;
ListNode *Cur = dummy->next;
ListNode *tmp = Cur->next;
while (tmp != NULL) {
Cur->next = tmp->next;
tmp->next = dummy->next;
dummy->next = tmp;
tmp = Cur->next;
}
Cur->next = NULL;
return dummy->next;
}
- 连续子数组最大和问题(和最大的连续子序列的和)
- 输出字符串中最长的回文子串长度？
https://blog.csdn.net/h_xy_zwb/article/details/64124271
DP:O(n^2)
string longestPalindrome(string s) {
int len=s.size();
vector
int maxres=0,idx=0;
for(int i=0;i for(int j=0,k=i;j if(k==j) flag[j][k]=1; else if(s[k]==s[j]&&j+1==k) flag[j][k]=2; else if(s[k]==s[j]&&flag[j+1][k-1]>0) flag[j][k]=flag[j+1][k-1]+2; else flag[j][k]=0; if(flag[j][k]>maxres){ maxres=flag[j][k]; idx=j; } } } return s.substr(idx,maxres); } 一个字符串,求最长无重复子串的长度？ 最长递增子序列： 思想：在求以ai为末元素的最长递增子序列时，找到所有序号在L前面且小于ai的元素aj，即j 剑指58 实现：设置两个指针，一头一尾，往中间移动； 一个字符串中{} [ ] ()匹配问题 bool isValid(string s) { std::stack for(int i = 0; i < s.size(); ++i) { char ch = s.at(i); if(ch == '(' || ch == '[' || ch == '{') st.push(ch); else if(st.size() > 0 && ((ch == ')' && st.top() == '(') || (ch == ']' && st.top() == '[') || (ch == '}' && st.top() == '{'))) st.pop(); else return false; } return st.size() == 0; } 可以用位运算实现，如果将所有所有数字相异或，则最后的结果肯定是那两个只出现一次的数字异或的结果，所以根据异或的结果1所在的最低位，把数字分成两半，每一半里都还有只出现一次的数据和成对出现的数据 int IpToInt(string s) { int ret=0; int num=0; for(int i=0;i { if(s[i]!='.') {num=num*10+(s[i]-'0');} else { cout< ret=ret<<8; ret+=num; cout< num=0; } } ret=ret<<8; ret+=num; return ret; } 基于归并排序的思想统计逆序对：先把数组分割成子数组，再子数组合并的过程中统计逆序对的数目。统计逆序对时，先统计子数组内部的逆序对的数目，再统计相邻子数组的逆序对数目。 通过n与n-1相& 清楚n最右边的1； int BitCount(int n){ int c=0;//计数器 while(n){ n&=(n-1); ++c; } return c; } Prim+ Kruskal算法 https://www.cnblogs.com/GHzz/p/9148279.html 递归 手写判断大小端的代码 https://blog.csdn.net/kit_9875507/article/details/44264663 大小端的本质就是不同的存储方式 大端模式：字数据的高字节存储在低地址中，而字数据的低字节则存放在高地址中。 小端模式：字数据的高字节存储在高地址中，而字数据的低字节则存放在低地址中。 根据这个特性，假设我们初始化了一个int变量i为0x12345678，其地址为0x100，根据定义在小端模式下 { if(checkSystem()) printf("little endian\n"); else printf("big endian\n"); return 0; } 单链表找倒数第n个节点，说所有你能想到的方法。 方法一：遍历链表，记录链表的长度total，再次遍历链表，第total - N - 1个节点就是查找结果，需要遍历两次链表 方法二：使用两个指针，通过移动指针，遍历一次链表，p指针首先移动n-1步，然后p和q同时移动，直到p.next == null，此时q所指向的节点就是所求 怎么把一颗二叉树原地变成一个双向链表？ 转换成有序双向链表：https://www.cnblogs.com/wanglei5205/p/8780086.html 怎么判断一个无符号的整数是不是2的n次方？ 思路：一个整数如果是2的整数次方，那么它的二进制表示中有且只有一位是1，而其他所有位都是0。把这个整数与这个整数减去1之后进行与运算，那么这个整数当中唯一的 1会变为0，这个整数也变为0； template { private : std::stack std::stack public: NewStack(); ~NewStack(); void push( T value) { stack_data.push (value); if (stack_support.size()==0 || stack_support.top()>value) stack_support.push(value); else: stack_support.push (stack_support.top()); } void pop() { if (stack_data.size()>0 && stack_support.size()>0) { stack_data.pop; stack_support.pop; } } T min() { if (stack_data.size()>0 && stack_support.size()>0) { return stack_support.top(); } } 使用队列实现栈: class MyStack { public: MyStack() { } void push(int x) { queue while(q.empty() == false){ //将队列q中所有元素存入辅助队列中 temp.push(q.front()); q.pop(); } q.push(x); //向队列中压入元素，放在队首 while(temp.empty() == false){ //逐个将辅助队列中的元素送回队列q中 q.push(temp.front()); temp.pop(); } } int pop() { int a = q.front(); //将队列首元素返回 q.pop(); //删除队首 return a; } int top() { return q.front(); //返回队首 } bool empty() { return q.empty(); } private: queue }; 用栈实现队列 class MyQueue { public: MyQueue() { } void push(int x) { //将元素放到栈底 stack while(s.empty() == false){ temp.push(s.top()); s.pop(); } s.push(x); while(temp.empty() == false){ s.push(temp.top()); temp.pop(); } } int pop() { int a = s.top(); s.pop(); return a; } int peek() { return s.top(); } bool empty() { return s.empty(); } private: stack }; 实现strstr函数 给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。 整数a和b，求a的b次方的最后三位数 . https://blog.csdn.net/forlove_you/article/details/51248978 遍历删除，考虑迭代器失效问题 { if（iter指向的元素是奇数） mapTest.erase(iter); } //错误，erase会让迭代器会失效！ { if（iter指向的元素是奇数） mapTest.erase(iter++);//正确，iter值传递之后，再++； } { if（iter指向的元素是奇数） } 翻转数组和恢复翻转数组 找分界点：找分界点可以用一个指针来，遍历找到第一个下降的点，如果没有找到，说明数组已经是排好的。 二分法： 普通 int binary_search(int*arr,int l,int h,int key){ while (l <= h){ int m = l + (h - l) / 2; if (arr[m] == key) return m; else if (arr[m] > key) h = m - 1; else l = m + 1; } return -1; } lower_bound int binary_search(int*arr, int l, int h, int key){//找到第一个插入的位置 while (l int m = l + (h - l) / 2; if (arr[m] >= key) return h=m; else l = m + 1; } } 排序 插入排序 void insert_sort(int* arr, int l, int h) { for (int i = l + 1; i <= h; ++i) for (int j = i; j > 0; --j){ if (arr[j] < arr[j - 1]){ iter_swap(&arr[j], &arr[j-1]); } } } 快速排序 int partition(int* arry, int l, int h){ int pivot = arry[h]; while (true){ while (arry[l] < pivot) ++l; while (arry[h] > pivot) --h; if (!(l < h)) return l; iter_swap(&arry[l], &arry[h]); ++l; --h; } } void quick_sort(int* arr, int l, int h) { if (l >= h) return; int m = partition(arr, l, h); quick_sort(arr, l, m-1); quick_sort(arr, m , h); } 堆排序 void percDown(int* arr, int l, int h, int k) { int child, tmp; for (tmp = arr[k]; (k - l) * 2 + l + 1 <= h; k = child) { child = (k - l) * 2 + l + 1; if (child + 1 <= h && arr[child] < arr[child + 1]) ++child; if (arr[child] > tmp) arr[k] = arr[child]; else break; } arr[k] = tmp; } void heap_sort(int* arr, int l, int h) { for (int i = l + (h - l) / 2; i >= l; --i) { percDown(arr, l, h, i); } for (int i = h; i >= l; --i) { int tmp = arr[l]; arr[l] = arr[i]; arr[i] = tmp; percDown(arr, l, i - 1, l); } } 归并排序 void merge_sort(int* arr, int l, int h) { if (l == h) return; int m = l + (h - l) / 2; merge_sort(arr, l, m); merge_sort(arr, m + 1, h); int * tmp = new int[h - l + 1]; int i = l, j = m + 1, k = 0; while (i <= m && j <= h) { if (arr[i] <= arr[j]) tmp[k++] = arr[i++]; else tmp[k++] = arr[j++]; } while (i <= m) tmp[k++] = arr[i++]; while (j <= h) tmp[k++] = arr[j++]; for (int i = l; i <= h; ++i) { arr[i] = tmp[i - l]; } delete []tmp; } 冒泡排序 void bubble_sort(int* arr, int l, int h) { for (int i = l; i <= h; ++i) { for (int j = l; j <= h - i + l - 1; ++j) { if (arr[j] > arr[j + 1]) { int tmp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = tmp; } } } } 选择排序 void select_sort(int* arr, int l, int h) { for (int i = l; i <= h; ++i) { int id = i; for (int j = i + 1; j <= h; ++j) { if (arr[j] < arr[id]) { id = j; } } int tmp = arr[i]; arr[i] = arr[id]; arr[id] = tmp; } } 手写String class String{ public: String(const char *str = NULL); //普通构造函数 String(const String &other); //拷贝构造函数 String & operator=(String &other) ; //赋值函数 ~String(void); //析构函数 private: char* m_str; }; //普通构造函数 String::String(const char* str){ if(str==NULL) //如果str为NULL，存空字符串{ m_str = new char[1]; //分配一个字节 *m_str = ‘\0′; //赋一个’\0′ }else{ str = new char[strlen(str) + 1];//分配空间容纳str内容 strcpy(m_str, str); //复制str到私有成员m_str中 } } //析构函数 String::~String(){ if(m_str!=NULL) //如果m_str不为NULL，释放堆内存{ delete [] m_str; m_str = NULL; } } //拷贝构造函数 String::String(const String &other){ m_str = new char[strlen(other.m_str)+1]; //分配空间容纳str内容 strcpy(m_str, other.m_str); //复制other.m_str到私有成员m_str中 } //赋值运算符函数 String & String::operator=(String &other){ if(this == &other) //若对象与other是同一个对象，直接返回本{ return *this } delete [] m_str; //否则，先释放当前对象堆内存 m_str = new char[strlen(other.m_str)+1]; //分配空间容纳str内容 strcpy(m_str, other.m_str); //复制other.m_str到私有成员m_str中 return *this； } memcpy函数的实现 void *memcpy(void *dest, const void *src, size_t count) { char *tmp = dest; const char *s = src; while (count--) *tmp++ = *s++; return dest; } strcpy函数的实现 char *strcpy(char *dst,const char *src) { assert(dst != NULL && src != NULL); char *ret = dst; while((* dst++ = * src++) != '\0') ; return ret; } BST的第K小的节点 http://www.cnblogs.com/grandyang/p/4620012.html 判断链表是否有环，如果有，返回环的入口节点；求环的长度 思路：采用两个指针walker和runner，walker每次移动一步而runner每次移动两步。当walker和runner第一次相遇时，证明链表有环 ；然后采用两个指针，一个从表头出发，一个从相遇点出发，一次都只移动一步，当二者相等时便是环入口的位置； ListNode *detectCycle(ListNode *head) { auto walker = head; auto runner = head; while(runner && runner->next)//设置快慢指针，并找到相遇点 { walker = walker->next; runner = runner->next->next; if(walker == runner) break; } if(!runner || !runner->next) //单链表无环 return nullptr; auto headWalker = head;//从头节点出发 auto crossWalker = walker; //从相遇点出发 while(headWalker != crossWalker) { headWalker = headWalker->next; crossWalker = crossWalker->next; } return headWalker; //环的入口点 } 基于归并排序的思想统计逆序对：先把数组分割成子数组，再子数组合并的过程中统计逆序对的数目。统计逆序对时，先统计子数组内部的逆序对的数目，再统计相邻子数组的逆序对数目。 翻转数组和恢复翻转数组 找分界点：找分界点可以用一个指针来，遍历找到第一个下降的点，如果没有找到，说明数组已经是排好的。 给定链表头指针，中间结点的指针，如何删除单链表中间节点 快慢指针找中间值， https://blog.csdn.net/cherrybomb1111/article/details/79803972 判断两个单链表是否相交，相交则找出两个链表的第一个公共子节点 思路1：分别遍历两个链表，得到分别对应的长度。然后求长度的差值，把较长的那个链表向后移动这个差值的个数，然后一一比较即可。 思路2：让两个指针分别从两条链表的开头开始往后遍历，当其中一条遍历到末尾时，我们将其跳到另一个条链表的开头继续遍历，一直遍历到两个指针相等为止。相等只有两种情况，一种情况是在交点处相遇，另一种情况是在各自的末尾的空节点处相等。， 为什么一定会相等呢，因为两个指针走过的路程相同，是两个链表的长度之和，所以一定会相等。 ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) { if (!headA || !headB) return NULL; ListNode *a = headA, *b = headB; while (a != b) { a = a ? a->next : headB; b = b ? b->next : headA; } return a; } r行c列的0,1数组，找到最大的全为1的正方形？ https://blog.csdn.net/nk_test/article/details/48901853 二叉树两个节点的最近公共祖先，没答出来 https://www.cnblogs.com/grandyang/p/4641968.html 去掉字符串中的空格字符 https://blog.csdn.net/qian2213762498/article/details/81705647 void trim(string &s) { int index = 0; if( !s.empty()) { while( (index = s.find(' ',index)) != string::npos) { s.erase(index,1); } } } 删除字符串开始和结尾处的空格，并将中间的多个连续的空格合并成一个。 void FormatString(char str[], int len) { if(str == NULL || len <= 0) return; int i = 0, j = 0; while(str[i] == ' ')//开头的空格 i++; while(str[i] != '\0') { if(str[i] == ' ' && (str[i+1] == ' ' || str[i+1] == '\0')) { //中间或者结尾的空格 i++; continue; } str[j++] = str[i++]; } str[j] = '\0'; } char *s1, const char *s2，删除s1中s2出现过的字符 思路：用一个256大小的数组，每个表示字符的状态，把s2读一遍，把每个字母对应的数字变为1表示存在，然后遍历s1，把状态为1的删掉 https://blog.csdn.net/m0_38099899/article/details/81231886 单链表判环 设两个指针，一个每次走一步的慢指针和一个每次走两步的快指针，如果链表里有环的话，两个指针最终肯定会相遇。 是不是：bool hasCycle(ListNode *head) { ListNode *slow = head, *fast = head; while (fast && fast->next) { slow = slow->next; fast = fast->next->next; if (slow == fast) return true; } return false; } 找环入口：ListNode *detectCycle(ListNode *head) { ListNode *slow = head, *fast = head; while (fast && fast->next) { slow = slow->next; fast = fast->next->next; if (slow == fast) break; } if (!fast || !fast->next) return NULL; slow = head; while (slow != fast) { slow = slow->next; fast = fast->next; } return fast; } 判断一个数是不是回文数 bool isPalindrome(int x) { if (x < 0 || (x % 10 == 0 && x != 0)) return false; int revertNum = 0; while (x > revertNum) { revertNum = revertNum * 10 + x % 10; x /= 10; } return x == revertNum || x == revertNum / 10; } http://www.cnblogs.com/grandyang/p/4125510.html 求一个集合的所有子集，递归实现，非递归实现 http://www.cnblogs.com/grandyang/p/4309345.html vector vector sort(S.begin(), S.end()); for (int i = 0; i < S.size(); ++i) { int size = res.size(); for (int j = 0; j < size; ++j) { res.push_back(res[j]); res.back().push_back(S[i]); } } return res; } 旋转有序数组的二分查找 http://www.cnblogs.com/grandyang/p/4325648.html 无重复数字：int search(vector int left = 0, right = nums.size() - 1; while (left <= right) { int mid = left + (right - left) / 2; if (nums[mid] == target) return mid; else if (nums[mid] < nums[right]) { if (nums[mid] < target && nums[right] >= target) left = mid + 1; else right = mid - 1; } else { if (nums[left] <= target && nums[mid] > target) right = mid - 1; else left = mid + 1; } } return -1; } 有重复数字：http://www.cnblogs.com/grandyang/p/4325840.html bool search(int A[], int n, int target) { if (n == 0) return false; int left = 0, right = n - 1; while (left <= right) { int mid = (left + right) / 2; if (A[mid] == target) return true; else if (A[mid] < A[right]) { if (A[mid] < target && A[right] >= target) left = mid + 1; else right = mid - 1; } else if (A[mid] > A[right]){ if (A[left] <= target && A[mid] > target) right = mid - 1; else left = mid + 1; } else --right; } return false; } 删除数组中的重复元素 有序数组中去除重复项 http://www.cnblogs.com/grandyang/p/4329128.html int removeDuplicates(vector if (nums.empty()) return 0; int j = 0, n = nums.size(); for (int i = 0; i < n; ++i) { if (nums[i] != nums[j]) nums[++j] = nums[i]; } return j + 1; } 实现一个计算器计算简单的表达式字符串 +-： http://www.cnblogs.com/grandyang/p/4570699.html +-*/: http://www.cnblogs.com/grandyang/p/4601208.html +-*/(): http://www.cnblogs.com/grandyang/p/8873471.html memcopy和memove的区别？memcopy和memove的实现？ https://blog.csdn.net/li_ning_/article/details/51418400 都是拷贝一定长度的内存的内容，区别是当内存发生局部重叠的时候，memmove保证拷贝的结果是正确的，memcpy不保证拷贝的结果的正确。 memcpy函数的实现 void *memcpy(void *dest, const void *src, size_t count) { char *tmp = dest; const char *s = src; while (count--) *tmp++ = *s++; return dest; } 给定一个二叉树，节点值为0-9，从根节点到叶子结点组成一个数，求二叉树所有组成的数的和 https://blog.csdn.net/i_am_bird/article/details/78173454 Rand()的范围是多少，要是生成大于范围的的随机数怎么实现 srand(time(0)); rand(); 0~32767 写一个二叉树翻转，然后写个测试(为了写这个测试我还白送一个二叉树层次遍历emmm) https://blog.csdn.net/qq_29762941/article/details/80909342 测试：反转两次，再和原来的二叉树比较是否相同 手写堆排序，然后分析下建堆时间复杂度(从n/2开始向上建堆的话是O(n)) https://blog.csdn.net/yuzhihui_no1/article/details/44258297 strcpy安全性，如何实现安全，strnpy,写一下并测试， https://blog.csdn.net/ZH___xin/article/details/51985562 写sql语句(A表存储有每个电话号码当月通话记录，表B是电话号码集合，求表B每个号码通话次数)，大概就是比较简单的连表查询，加count select B.telno, count(B.telno) from A right join B where A.telno = B.telno group by B.telno 假设上面题中A B两个表存在文件，怎么编程统计？ 我答的使用hashmap存储电话和次数，时间复杂度呢？ 只需要扫描两个文件各一遍O(n+m) 两字符串最长公共子串， 最长公共子序列 https://blog.csdn.net/u012426298/article/details/82796660 打印二叉树每层最右边的节点 层序遍历 LeetCode 199 http://www.cnblogs.com/grandyang/p/4392254.html 手写代码 回形矩阵 http://www.cnblogs.com/grandyang/p/4362675.html 判断在一个矩阵中是否存在一条包含某字符串所有字符的路径 https://blog.csdn.net/qq_21997625/article/details/84640353 3sum 数组中三数之和为0的所有三元组 leetcode 15 微信的附近的人这个功能，如果让你实现，你准备怎么做， 地理位置网格分块，存块ID，然后四叉搜索。你的经纬度换算成网格ID，同网格的人撸出来，临近网格的人撸出来，搞定。把地理位置分块，怎么把经纬度转化成网格 ID 呢。本质上就是hash 客户端固定时间发送经纬度（x,y）到服务器s，服务器存储每个登陆的用户的经纬度到表t中，表t按照经纬度分表，将地图分成一个个的小格子。当用户点击“附近的人”时，对用户（x,y）进行计算，最多一次查询其中的4个格子（子表），计算两点间距离获取结果（有点像桶排序）。性能上可以将表t替换为内存结构，容灾即可。 MongoDB的LBS功能实现附近的人 https://www.nowcoder.com/discuss/165952?type=0&order=0&pos=414&page=1 微信小程序团队一共有 n 名成员，决定出去秋游，在海边遇到出租摩托艇的杰克马，马先生手上有 m 辆待出租的摩托艇，价格分别是 b1 、b2 ... bm; 由于习惯了微信支付，团队中每个人身上的现金都有限，分别是 a1 a2 ... an，对了，一起出门的老板还带有 S 元的团队经费，这个经费是每个人都可以使用的 那么考虑以下两个场景 场景1 团队成员都很有爱，都愿意借钱给其他同事，那么这时候团队最多能租到多少摩托艇 //贪心法；把所有的钱收集起来，按摩托艇的价格从低到高租借摩托艇 场景2 团队成员都十分小气，是不愿意借钱给别人的,那么请考虑以下两个问题 //问题一 老板是否能想到一个策略，使得所有人都能租到摩托艇？ //贪心法；钱少的人租借便宜的摩托艇，补贴 public static boolean isAll(int[] n, int[] m, int S){ if (n.length > m.length) { return false; } Arrays.sort(n); Arrays.sort(m); for (int i=0; i int need = n[i] - m[i]; if (need < 0) S += need; } return S >= 0; } //问题二 请问给出一个策略 // - 使得整个团队租到最多的摩托艇 // - 在租到最多摩托艇的情况下，整体的支出尽量的少 //二分法+贪心 private static int n[]; private static int m[]; private static int S; public static int[] isAll(int[] n, int[] m, int S){ Arrays.sort(n); Arrays.sort(m); Main.n = n; Main.m = m; Main.S = S; int l =0, r = m.length; //摩托艇的数量 while (l < r) { int mid = l + r + 1 >> 1; if (can(mid)) { l = mid; } else { r = mid - 1; } } int ans = 0; for (int i=0; i ans += m[i]; } return new int[] {l, ans}; } private static boolean can(int count) { int tmpS = S; for (int i = count-1,j = n.length-1; i>=0; i--, j--) {//让最多钱的人买最贵的摩托艇 if (n[j] < m[i]) { tmpS -= (m[i] - n[j]); } if (tmpS < 0) { return false; } } return true; } 判断一个字符串是不是两个有序的字符串交错组成的。 Leetcode 97 编程题：递增数组中找两个数和为某个固定值。设计测试用例 Leetcode 1 给你一个数组和数组元素的个数，求平均值。 int avg(int x, int y) { return (x & y) + ((x ^ y) >> 1); } 两个非常大的数相加 Leetcode 415
.对于string类型的：使用algorithm中的reverse函数，reverse(s.begin(),s.end());
对于用char定义的字符串：使用string.h中的strrev函数，char s[]="123456";//不能是string类型；strrev(s);
这样继续对每一半相异或则可以分别求出两个只出现一次的数字
0x100一个字节内的值为0x78，类推0x101=>0x56，0x102=>0x34，0x103=0x12，根据这个编程如下
int main(void)
iter=mapTest.erase(iter);// erase() 成员函数返回下一个元素的迭代器
顺时针回形打印矩阵的元素LeetCode 54
从实际的微信提供的功能来看，附近的人并不太多，估计是其对地图划分的格子很小。intisAll(int a[n], int b[m], intS){ int sum=0; for(int i=0;i；++i) sum+=a[i]; sum+=S; sort(a,a+n); inti = 0; while(sum - m[i] > 0) { sum -= m[i]; i++; } returni; }