我有一个梦想

inline int get_list_len(ListNode *root) { int len=0; while(root){ root=root->next; ++len; } return len;

工作原理看完代码之后，让我们看看它对数组都做了写什么。首先，该方法选中数组的最后一个元素：接下来确定挑选随机元素的范围，从数组的第一个元素到上一步选中的元素都属于这一范围：确定范围后，从中随机挑选一个数，这里假设随机选中的元素为 4：然后交换最后一个元素和随机选中的元素的值：上面的交换完成后，相当于我们完成了对数组最后一个元素

bool isLoop(ListNode *root){ if(!root&&!root->next) return false; ListNode *fast=root; ListNode *slow=root; while(fast&&fast->next){ slow=slow->

static int partition(int arr[],int left,int right) { if(left==right) return left; int i=left,j=right; int tmp=arr[left]; while(i

在一个字符串(1 char firstNoRepeaChar(const string &target){ if(target.empty()) return '\0'; map check; for(auto e:target) ++check[e];

深度优先遍历 1．深度优先遍历的递归定义　　假设给定图G的初态是所有顶点均未曾访问过。在G中任选一顶点v为初始出发点(源点)，则深度优先遍历可定义如下：首先访问出发点v，并将其标记为已访问过；然后依次从v出发搜索v的每个邻接点w。若w未曾访问过，则以w为新的出发点继续进行深度优先遍历，直至图中所有和源点v有路径相通的顶点(亦称为从源点可达的顶点)均已被访问为止。若此时图中仍有未访问的顶

int GetLeafNum(TreeNode *root){ if(!root) return 0; else if(!root->left&&!root->right) return 1; else return GetLeaf

For example, this binary tree is symmetric: 1 / \ 2 2 / \ / \3 4 4 3But the following is not: 1 / \ 2 2 \ \ 3 3

题目：计算二叉树的最小深度。最小深度定义为从root到叶子节点的最小路径。 int minDepth(TreeNode *root){ if(!root->left&&!root->right) return 1; int L,R; L=R=INT_MAX; if(r

经典解法：快慢指针+Hash表 void deletechar(char *str) { if(str==nullptr) return ; map check; char *slow=str; while(*str){ if(check[*str]==

bool verify_is_post(int arr[],int left,int right) { if(right<=left) return true; int root=arr[right]; int i,j; for(i=left;i<right;++i) if(ro

ListNode *fun(ListNode *root,int k) { if(!root||k<=0) return nullptr; int len=0; for(ListNode *p=root;p;p=p->next) ++len; if(k>len)

题目：在字符串中找出连续最长的数字串，并把这个串返回。例如：输入"abcd12345ed125ss123456789"，函数将返回123456789。 char* continueMax(char *intput) { if(!input) return 0; char *head=input ;

给出已排序数组a，b，长度分别为n，m，找到排在第k位置的数。bool solution(int a[],int n,int b[],int m,int &can){ if(!a||!b||m+n<k) return false; int i=0,j=0; int cur=0; while(i<n||j<m){ int v1=i

strcpy函数char* strcpy(char *dest,const char *src) {        assert(dest!=NULL&&src!=NULL);        char *res=dest;        while(*dest++=*src++)            continue;        return res;}str

经典的解法：快慢指针void deletechar(char *str,int key){ if(str==nullptr) return ; char *slow=str; while(*str){ if(*str != key) *slow=*str; ++str; } }

思路：用两次二次查找即可，第一次查找确定key第一次出现的位置，第二次查找确定key最后一次出现的位置。 int fun(vector &arr,int size,int key) { if(arr.empty()) return 0; int left =0; int right=size

void fun(char *str,int begin,int end) { if(begin==end){ cout<<str<<endl; return ; } for(int i=begin;i<=end;++i){ if(i!=begin)

标点符号和普通字母一样处理。如："I am a student."翻转成"student. a am Iinline void swap(char &a,char &b) { a^=b; b^=a; a^=b; } void reverse(char *pbegin,char *pend)

void leveltravel(TreeNode *root) { if(!root) return ; vector que; que.push(root); coutval<<endl; while(!que.empty())

题目：有一组数，除了一个数出现1次，其余的数均出现2次，请找出这个只出现1次的数。int fun(vector &arr){ int res=0; for(auto e:arr){ res^=e; } return res;}

题目：有一组数，除了一个数出现1次，其余的数均出现3次，请找出这个只出现1次的数。int FindNumberAppearOnce2(vector &arr) { int res,count; res=0; for(int i=0;i<31;++i){ count=0; for(auto e

清除整数a最右边的1可以使用这个操作：a&(a-1)int tatalOne(int number){ int count=0; while(number){ number=number&(number-1); ++count; } return count;}

可以转换成判断一个整数的二进制是否只有一个1bool solution(int number){ int count=0; while(number){ number=number&(number-1); if(++count>1) return false; } return true;}

int MoreThanHalfNum(vector &nums){ assert(!nums.empty()); int can=nums[0]; int times=1; const int n=nums.size(); for(int i=1;i<n;++i){ if(times==0) can=

int lengthOfLIS(vector& nums) { if(nums.empty()) return 0; const int n=nums.size(); int dp[n]; fill(dp,dp+n,1); int res=1; for(int i=1;i<n

给出一棵二叉树，寻找一条路径使其路径和最大，路径可以在任一节点中开始和结束（路径和为两个节点之间所在路径上的节点权值之和）int backtracing(TreeNode *root,int &maxp){ if(!root) return 0; int L,R; L=backtracing(root->left,maxp

TreeNode *lowestCommonAncestor(TreeNode *root, TreeNode *A, TreeNode *B) { if(!root) return NULL; if(root==A) return A; if(root==B) return B

int maxDepth(TreeNode *root) { return root==NULL?0:max(maxDepth(root->left),maxDepth(root->right))+1; }

int BinarySort(int arr[],int n,int key){ if(arr==NULL||n<1) return -1; int left=0,right=n-1; while(left<=right){ int mid=left+(right-left)/2; if(arr[mid]<ke

void findMaxAndMin(int nums[],int n,int &maxsum,int &minsum){ if(!nums) return ; int i=0; if(n&1){ maxnum=minnum=nums[0]; i=1; }else{ maxnum=INT_MIN; minnum=INT_MA

Difficulty: EasyGiven a binary tree, find its minimum depth.The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node./** * Definition fo

int searchRotateArray(int arr[],int n,int key){ if(!arr||n<1) return -1; int right=n-1,left=0; while(left<=right){ int mid=left+(right-left)/2; if(arr[mid]==key) return

题目：给一个整数N，求它的阶乘N!，有几个0结尾                       方法一    要计算Z，最直接的方法就是求出N的阶乘的所有因式(1,2,3,...,N)分解中5的指数。然后求和。int fun1(int n){ int num = 0; int i,j; for (i = 5;i <= n;i +=

题目：输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。                                                                   如图，输入上图的二叉树和整数 22，则打印出两条路径，第一条路径：10, 12； 第二条路径为：10， 5， 7.

原理如果想判断一个元素是不是在一个集合里，一般想到的是将集合中所有元素保存起来，然后通过比较确定。链表、树、散列表（又叫哈希表，Hash table）等等数据结构都是这种思路。但是随着集合中元素的增加，我们需要的存储空间越来越大。同时检索速度也越来越慢。Bloom Filter 是一种空间效率很高的随机数据结构，Bloom filter 可以看做是对 bit-map 的扩展,

template class ListNode{ public: ListNode *next; T elements;};非递归ListNode *ReverseList1(ListNode *root){ ListNode *link,*prev=nullptr; while(root){ link=root->next;

int solution(int a[],int n,int b[],int m){    if(!a||!b)        return 0;    int dp[n+1][m+1];    int res=INT_MIN;    memset(dp,sizeof(dp),0);    for(int i=1;i        for(int j=1;j

1.Bloom filter 适用范围：可以用来实现数据字典，进行数据的判重，或者集合求交集 基本原理及要点： 对于原理来说很简单，位数组+k个独立hash函数。将hash函数对应的值的位数组置1，查找时如果发现所有hash函数对应位都是1说明存在，很明显这个过程并不保证查找的结果是100%正确的。同时也不支持删除一个已经插入的关键字，因为该关键字对应的位会牵动到其他的关键字。

二查搜索树中的第k个结点即二叉搜索树中第k小或第k大的节点 void get_k_num(ListNode *root,int k) { if(!root) return ; get_k_num(root->left,k); if(--k==0) coutval<<endl;