算法

在算法和数据结构上，我觉得我是一个彻彻底底的小白，开始刷题吧。 #阶梯训练 ###1. 两个字符串是变位词 ######写出一个函数 anagram(s, t) 判断两个字符串是否可以通过改变字母的顺序变成一样的字符串。 样例 给出 s = "abcd"，t="dcab"，返回 true. 给出 s = "ab", t = "ab", 返回 true. 给出 s = "ab", t = "ac", 返回 false. 首先看到这个题目 我们想到的就是字符串排序了，通过排序把字符调换成有顺序的字符串，再来比较。 所以就会出现以下代码 public class Solution { /** * @param s: The first string * @param b: The second string * @return true or false */ public boolean anagram(String s, String t) { //先查看长度是否相等，不相等则返回false if(s.length() != t.length()){ return false; } //转换成字符 然后排序 char[] sChar = s.toCharArray(); char[] tChar = t.toCharArray(); Arrays.sort(sChar);

#include<iostream> using namespace std; //选择排序 void SelectSort(int list[],int n) {int temp,t,i,j,big; for(i=0;i<n-1;i++) {big=i; for(j=i+1;j<n;j++) { if(list[big]<list[j]) big=j; } temp=list[i]; list[i]=list[big]; list[big]=temp; } for(t=0;t<n;t++) {cout<<list[t];} } //冒泡排序 void bubble(int list[],int n){ int i,temp; for(int p=1;p<n;p++) { for(i=0;i<n-p;i++) if(list[i]<list[i+1]) {temp=list[i]; list[i]=list[i+1]; list[i+1]=temp; } } for(i=0;i<n;i++) {cout<<list[i];}} //插入排序 void Insert(int list[],int n) { for(int i=1;i<n;i++) { int key = list[i]; int j=i-1; while(j>=0&&key>list[j]) {list[j+1]

我有一个这样的线程池的场景，相信很多人都遇到过： 1，每个用户都可以添加多个任务； 2，有很多的用户和很多的任务； 3，每个用户添加的任务必须有序串行执行，即在同一时刻不能有同时执行一个用户的两个任务； 4，实时性：只要线程池线程有空闲的，那么用户提交任务后必须立即执行；尽可能提高线程的利用率。 代码比较简洁，基本满足上述要求： public class SerialThreadExecutor { private Executor executor; private ConcurrentMap<Object, SequentialJob> serialJobs = new ConcurrentHashMap<Object, SequentialJob>(); public SerialThreadExecutor(Executor executor) { super(); this.executor = executor; } public void executeSerially(Object key, Runnable r) { SequentialJob job = serialJobs.get(key); if (job == null) { job = new SequentialJob(key); SequentialJob oldJob = serialJobs

#include <iostream> using namespace std; int binarySearch(int a[],int n,int key) { int low,high,mid; low = 0; high = n-1; while(low <= high) //记得这个等号... { mid = (low + high)/2; if (key < a[mid]) high = mid - 1; else if (key > a[mid]) low = mid + 1; else return mid; } } int main(int argc, char const *argv[]) { int a[] = {1,1,2,3,5,7,9}; int pos = binarySearch(a,sizeof(a)/sizeof(int),5); cout << pos; return 0; } 来源： oschina 链接： https://my.oschina.net/u/857259/blog/86160

题目 求从10到100中能被3或5整除的数的和 解答 解答一 public class Test { public static void main(String[] args) { int sum = 0; for (int i = 10; i < 100; i++) { if (i % 3 ==0 || i % 5 == 0) { sum += i; } } System.out.println(sum); } } 解答二 /** * @brief count tot nums val in 10~100 which 10%3 = 0 or 10%5 = 0 * @param void * @return tot nums */ #include <stdio.h> #define DEBUG 1 int table[120]; #define END 100 #define BASE3 12 #define STEP3 3 #define BASE5 10 #define STEP5 5 int solve(void){ int sum = 0; int pos3 = BASE3; int pos5 = BASE5; while(pos3 < END){ if(pos5 < END){ table[pos5] = 1; sum += pos5; pos5 += STEP5;

B 树、 B- 树、 B+ 树、 B* 树都是什么 B 树 即二叉搜索树： 1. 所有非叶子结点至多拥有两个儿子（ Left 和 Right ）； 2. 所有结点存储一个关键字； 3. 非叶子结点的左指针指向小于其关键字的子树，右指针指向大于其关键字的子树； 如： B 树的搜索，从根结点开始，如果查询的关键字与结点的关键字相等，那么就命中；否则，如果查询关键字比结点关键字小，就进入左儿子；如果比结点关键字大，就进入右儿子；如果左儿子或右儿子的指针为空，则报告找不到相应的关键字； 如果 B 树的所有非叶子结点的左右子树的结点数目均保持差不多（平衡），那么 B 树的搜索性能逼近二分查找；但它比连续内存空间的二分查找的优点是，改变 B 树结构（插入与删除结点）不需要移动大段的内存数据，甚至通常是常数开销； 如： 但 B 树在经过多次插入与删除后，有可能导致不同的结构： 右边也是一个 B 树，但它的搜索性能已经是线性的了；同样的关键字集合有可能导致不同的树结构索引；所以，使用 B 树还要考虑尽可能让 B 树保持左图的结构，和避免右图的结构，也就是所谓的“平衡”问题； 实际使用的 B 树都是在原 B 树的基础上加上平衡算法，即“平衡二叉树”；如何保持 B 树结点分布均匀的平衡算法是平衡二叉树的关键；平衡算法是一种在 B 树中插入和删除结点的策略； B- 树 是一种多路搜索树（并不是二叉的）：

代码： #!/usr/bin/env python # unique factorization # e.g # 7 is a prime number # 6000 = [2^4]*[3^1]*[5*3] import sys def uniq_fac(num): ''' unique factorization of integer num return a tuple (flag, prime-list, index-list) flag: num is prime or not prime-list: [p1, p2, ...pr] index-list: [e1, e2, ...er] ''' if not isinstance(num, int): print num, 'not an integer' sys.exit(1) flag = 1 prime_list = [] index_list = [] for i in xrange(2, num/2+1): if num%i == 0: prime_list.append(i) idx = 0 while num%i == 0: num = num/i idx += 1 index_list.append(idx) flag = 0 return (flag, prime_list, index_list)

超过O(n)时间复杂度的算法都是在耍流氓，借着机器性能好，你就可以不考虑算法复杂度了？就可以 O(n^2),O(n^3)嘛。。。 什么狗屁数学，什么狗屁学术，就是你自己编码水平太滥，才需要更强大的硬件。 一台服务器你用了不爽，要用十台。。要用千台。。干呀。。 你要1TB的传输量，一台机器硬盘IO怎么也得80-100MB/s， 1TB除下不就好了。 用这么多硬盘就行。为毛要比这个多得多的硬件。。。 还有CPU和内存，老是想码几十万行代码，我靠，那种功能，几万行就能解决好了，而且还用更高效的算法，O(logn)就搞定，你非要整个o(n^2),试问你是在应用，不是在学习。。。 还有，你想要效率，又不想学C，天天搞Java，你搞毛线呀。。。 Java动不动就几MB，几十MB的内存占用。。各种虚拟资源，你看C。。程序很小很小，3000行的代码，只有100ＫＢ。。。。　　１ＭＢ得要多少行Ｃ代码。。而内存占用，从不含糊，需要多少就用多少，不会多一点乱用的内存。。。 还有现在开源好多也是这种风气。。。不考虑高性能。。　　一秒种，插入１０万次到磁盘，很艰难。　而要做到一秒插入３０万条（７８字节一条）磁盘，更难。 一般的开源软件，能到一万条就不错了。。。 哎，开源的东西，好多把高性能给放弃了，就算用了高性能，也需要大量的硬件，如：Ｈａｄｏｏｐ。 memcached，内存里的数据库，竟然

107. Binary Tree Level Order Traversal II Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root). For example: Given binary tree [3,9,20,null,null,15,7] , 3 / \ 9 20 / \ 15 7 return its bottom-up level order traversal as: [ [15,7], [9,20], [3] ] 就是复习以下树的分层遍历 我发现leetcode上基本上不用前序、中序、后序、分层遍历这些词，大多数都只有dfs和bfs 练习一下图和树的遍历，可以顺便把队列和栈之类的一起复习了 bfs用一个队列，而需要返回的列表用链表头插法就行了 public class Solution { public List<List<Integer>> levelOrderBottom(TreeNode root) { List<List<Integer>> list = new LinkedList<>(); if(root==null){

零、数据结构和算法系列目录 数据结构和算法系列目录(不断更新)： http://my.oschina.net/liuzeli/blog/128278 一、归并排序简介 归并排序和插入排序一样，其核心是基于比较的，所以也是比较排序中的一种。归并排序运用的分治算法的思想。在介绍归并排序的同时也简单的介绍一下分治算法，这种算法的核心讲解会在后续的博客中介绍。回国头来继续说归并排序。归并排序有着很好的应用场景，它适合给大规模的数据排序，当数据量非常大时，内存排序困难可以对归并排序稍加改动让其支持分批从硬盘读取数据并进行排序，最后把结果进行合并。归并排序(二路归并)的主要思路就是假设两个数组A和数组B分别已经是排序好的，再对这两个数组A和B进行合并成为一个新的排序好的数组。这一步是归并排序的核心步骤，如果对于这个待排序数组来说，开始先对数组两个两个元素进行排序，在对其合并变成4个元素为一组，在变成8个元素为一组，从而到最后完成所有数据的排序。 二、分治算法的简介 分治算法的主要核心是分而治之的思想，即把原文题进行分解，分解成若干的子问题，在对子问题进行求解，在对所有子问题的答案进行合并从而得到原问题的结果。可以表示成下面叙述的过程。 1. 分解：将原问题分解成若干个规模较小且相对独立的的与原问题形式相同的子问题。 2. 求解：若子问题规模较小并且容易解决时将对其进行求解，否则递归的解决子问题