专栏

#include <iostream>using namespace std;/**归并算法 *将数组a中的下标s~m 和m~e按从小到大的顺序合并 */void Merge(int *a,int s,int m,int e){ int n1,n2; n1=m-s+1; n2=e-m; int *l=new int[n1+1]; int *h=n

/* c(n,k)=c(n-1,k-1)+c(n-1,k)*/class Solution {public: vector<vector<int>> combine(int n, int k) { vector<vector<int>> result; if(k==n||k==0) {

class Solution {public: int lengthOfLongestSubstring(string s) { unordered_map<char,int> map; int start=0;//start为不重复substring 的开始下标 int end=0;//end为不重复substring 的结束下标

class Solution {private: vector<vector<string>> result; vector<string> curlist; bool judge(string &s,int start,int end) { if(end==start) return true; while(end>start)

class Solution {public: bool isMatch(string s, string p) { int ppos=0; int spos=0; int star=-1;//找到的'*'的下标 int match; while(spos<s.size()) {

题目要求找到所有连续的数字的个数 本来想先排序 然后看前面的一个数字是不是等于当前数字-1 然后进行计数 但是排好序后复杂度就是nlogn了 所以想了另外一种方法 扫描每个数a 然后寻找a-1 a-2 …. a+1 a+2…. 把比a大的和比a小的相加 就得到了连续的个数 来更新maxlen 但是 有个问题 就是怎么确定a-1在不在数组中 这里使用hash表 这样寻找每

题目的意思就是 在s中寻找包含所有words中单词的子字符串的开始下标(不考虑words单词的顺序) 思路为 用一个map(string,int)来记录所有单词及其出现的次数 然后搜索所用s中所有可能出现的位置class Solution {public: vector<int> findSubstring(string s, vector<string>& words) {

这个一个人链表的深度拷贝 old链表为 第一步 在每一个old节点的后面加上新的copy节点 ，形成新的链表如下图所示 copy节点中的random指针指向 它要复制的old节点 next指针指向 要复制节点中的old节点中的next 第二步 更新copy节点中random指针值 copy节点中的random指针现在指向 它要copy的节点 如果copy->random->r

时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 小Hi和小Ho是一对好朋友，出生在信息化社会的他们对编程产生了莫大的兴趣，他们约定好互相帮助，在编程的学习道路上一同前进。这一天，他们遇到了一本词典，于是小Hi就向小Ho提出了那个经典的问题：“小Ho，你能不能对于每一个我给出的字符串，都在这个词典里面找到以这个字符串开头的所有单词呢？”身经百战的小Ho答道：“怎么

题目很简单 就是把链表拆分成已经排好序的 ，没有排序的 ，从没有排序的中不断的取元素插入到排好序的链表中class Solution {public: ListNode* insertionSortList(ListNode* head) { if(!head||!head->next) return head; ListNode *

class Solution {private: void backtrack(vector<string> &result,string cur,int left,int right,int max) { if(cur.length()==2*max) { result.push_back(cur);

class Solution {private: void combanation(vector<vector<int>> &result,vector<int> &cur,vector<int> &candidate,int target,int begin) { if(!target) { result.push_back

class Solution {private: ListNode *head;public: /** @param head The linked list's head. Note that the head is guaranteed to be not null, so it contains at least one node. */ Soluti

class MinStack {private: long min; stack<long> *lstack;public: /** initialize your data structure here. */ MinStack() { lstack=new stack<long>(); } void push(int x) {

class Solution {public: int singleNumber(vector<int>& nums) { map<int ,int > count; for(int i=0;i<nums.size();i++) { count[nums[i]]++; } for(auto it=count.begin()

class Solution {public: int singleNumber(vector<int>& nums) { map<int,int > count; for(int i=0;i<nums.size();i++) { count[nums[i]]++; } for(auto

class Solution {public: int candy(vector<int>& ratings) { int rsize=ratings.size(); if(rsize<=1) return rsize; vector<int> num(rsize,1); for(int i=0;i<n

class Solution {public: int canCompleteCircuit(vector<int>& gas, vector<int>& cost) { int start=gas.size()-1; int end=0; int sum=gas[start]-cost[start]; while(start

class Solution {public: string convertToTitle(int n) { string result; while(n) { char ch=(n-1)%26+'A'; n=(n-1)/26; result=ch+result;

class Solution {public: int ladderLength(string beginWord, string endWord, unordered_set<string>& wordList) { int dist=2; unordered_set<string> head,tail,*phead,*ptail; hea

class Solution {private: void combination(vector<vector<int>>&result,vector<int> &cur,vector<int> &candidate,int target,int begin) { if(!target) { result.push_back(

方法1 先排序 后判断是否相等#include "stdafx.h"#include <algorithm>#include <string>using namespace std;class Solution {public: bool isAnagram(string s, string t) { sort(s.begin(), s.end());

https://leetcode.com/problems/intersection-of-two-linked-lists/ 由于链表的最后是合在一起的 所以在遍历的时候到末尾的长度一定相等的 假设两条链表的长度是m n m>n 方法是从短链表的头部 和 从长链表 距离链表尾部和短链表一样长的地方开始遍历 如果指向相同的地址就把这个地址返回x指向长链表的首部 y指向短链表的首部 x

贪心算法在解决问题的策略上目光短浅，只根据当前已有的信息就做出选择，而且一旦做出了选择，不管将来有什么结果，这个选择都不会改变。换言之，贪心法并不是从整体最优考虑，它所做出的选择只是在某种意义上的局部最优。贪心算法对于大部分的优化问题都能产生最优解，但不能总获得整体最优解，通常可以获得近似最优解。 引例 [找零钱] 一个小孩买了价值少于1美元的糖，并将1美元的钱交给售货员。售货员希望用数目最少的

今天在利用BFS来遍历无向图的时候发现了一个问题 ，怎样标记标记无向图的状态以前是否被访问过来避免重复的访问产生的大量的空间和时间的浪费，最简单的方法就是将无向图的每种状态转化成一个数字，然后再设置一个数组来标记是否被访问过。问题的关键在于怎样将无向图的状态转化成数字。再将无向图具体一点到利用一个数组表示的无向图将设这个数组表示的是3*3的一个无向图 在这3*3的图中分别填上0~8数字，则每个里面

链表是数据结构中常见的一种，使用也很频繁 。但大多时候可以使用链表则也可以使用数组 下面在一个例子中分别使用数组和链表来对比下两者的区别和各自的特点. 题目：小球 从左到右一次编号为 1,2,3,4,5…n 可以执行两种指令 A x y 或者B x y A x y 为将x 编号的球放到y编号的球的左边 B x y 为将x编号的球放到y编号的球的右边 最后输出整个球的经过调整后的顺序

栈是数据结构里最常用的一种，有时候给一个有序的输入要判断一种顺序是否符合栈的输出. 例如：输入为：1 2 3 4 5 6 来判断怎样的输出是符合栈的特点的输出 输出为 : 1 2 3 4 5 6 是符合的 因为可以1入1出 2 入2出 ……最后6入6出。 输出为：6 5 4 3 2 1也是可以的 因为可以1 2 3 4 5 6都入栈然后在一一出栈 输出为：5 6 2 3 4 1 是

```#include <iostream>#include <iomanip>using namespace std;const int SIZE=12;int numberOfDigits(int[],int); //求数位void distributeElement(int[],int[][SIZE+1],int); //分布void collectElement(int[],

#include #include enum STATUS{ SUCCESS, FAILURE};/*****************************************//*将a上最上面number个圆盘可以经过b搬到c上*//*****************************************/void move(int number,char a,char b,ch

常常在运算表达式中用各种括号的存在，可怎么判断括号是否合法呢？如[()]()  就是合法的    而(()(])就是不合法的假设用户先输入（[(则后面必须先检测有无）与第三个相匹配，再检测有无]与第二个相匹配，再检测有无）与第一个相匹配与堆栈后进先出的特点相匹配我的思路如下出现一个[就向堆栈中压入1出现一个（就向堆栈中压入2而出现一个]就从堆栈中弹出一个数并检查是否为1

进制转换可以用递归来做，其实用递归呢也是用堆栈来实现的下面的这段程序是用堆栈实现的：并通过测试#include #include #define STACK_INIT_SIZE 100#define STACK_INCREMENT 10#define SElemtype inttypedef struct{ SElemtype *top; SElemtype

在linux下 创建独立线程来输出小于或等于用户输入数的所有素数#include #include #define MAX_SIZE 256int primes[MAX_SIZE];void *runner(void *param);int main(int argc, char *argv[]){　　int i;　　pthread_t tid; 　　p

最小生成树的kruskal算法的伪代码如下 w[i]为边的权值，u[i],v[i]分别为边的端点的下标 mst为最小生成树的所有边的结合 n为顶点的个数 m为边的个数将边按权值排序w[0]<=w[1]<=……..<=w[m-1]; 初始化每个顶点属于不同的连通分量; for(i=0;i#include <iostream>using namespace std;const int NMA

这个程序的思路是这样的 比方说 输入17*15 第一步先将输入的字符串类型转换成int类型的向量并反向从低位到高位进行存储 就是 在int向量中 为 7 1 和 5 1 先存低位再存高位 这样 做的主要目的是为了 方便计算时的进位操作 (7,1 )*(5,1)得（35,12,1） 再将（35,12,1）做进位处理 左边是低位右边是高位这个进位操作就显得很简单了 （5,15,1）->(5,5

class Solution {public: bool isPowerOfTwo(int n) { if (n >0 && (n&n - 1) == 0) return true; else return false; }};

Left-Leaning RedBlack Tree 是一种redblack tree 它总是喜欢把红节点放在左子树上 它符合红黑树的所有性质 （1） 所有的节点要么是红色的要么是黑色的 （2） 红色节点的子节点是黑色节点 （3） 叶子节点（NIL）节点是黑色的 （4） 一个节点到任意一个叶子节点路径上的所有的黑色节点的个数是想等的 （5） 根节点为黑色节点 redblacktree

// interviewproblem.cpp : Defines the entry point for the console application.////整形数组 {1，1，2,2，3，3，4,4,5,5} ，去掉重复数结果是{1，2，3，4,5}并返回个数5。#include "stdafx.h"#include <iostream>#include <stdlib.h>us

// MicrosoftInterviewProblem.cpp : Defines the entry point for the console application.//两个含有n个元素的有序（非降序）整型数组a和b（数组a与b中都没有重复元素），求出其共同元素，//a = 0, 1, 2, 3, 4//b = 1, 3, 5, 7, 9//那么它们的交集为{ 1, 3 }。#inc

// MicroSofrInterviewProblem2.cpp : Defines the entry point for the console application.//有若干个给定的数（都小于N）,问从中任意取几个数相加，可以得到多少个不同的结果.//处理这种类似背包的时候，注意内层循环一定要memcpy重建一个副本，不然会陷入死循环并越界。如题，j = 0, 当0 + 1记录在re

题目:给出N个1-9的数字 (v1,v2,…,vN)，不改变它们的相对位置，在中间加入K个乘号和N-K-1个加号，（括号随便加）使最终结果尽量大。因为乘号和加号一共就是N-1个了，所以恰好每两个相邻数字之间都有一个符号。并说明其具有优化子结构性质及子问题重叠性质。（20分） 例如： N=5, K=2，5个数字分别为1、2、3、4、5，可以加成： 1*2*(3+4+5)=24 1*(2+3)