陈鹏万里

封装成类：package com.roc.algorithms.sort;/** * 堆排序 * a[0]不用，实际元素从角标1开始 * 父节点元素大于子节点元素 * 左子节点角标为2*k * 右子节点角标为2*k+1 * 父节点角标为k/2 * * @author roc */public class HeapSort { public static voi

两种类似的方式：#include //交换数组元素void swap(int *a,int i,int j){ int t = a[i]; a[i] = a[j]; a[j] = t;}//打印输出数组void print_arr(int *a,int len){ int i; if(len<1){ //数组长度必须大于0

本算法主要解决动态连通性一类问题，这里尽量用精炼简洁的话来阐述。数据结构描述：有N个节点（索引0~N-1），可以查询节点数量可以连接两个节点可以查询两个节点是否连通算法大致设计思路：每个节点初始化为不同的整数标记通过一个辅助函数查询某个节点的标记值如果两节点标记相同，说明两节点是连通的抽象基类：package com.roc.algorithms.u

封装成函数：//交换数组元素void swap(int *a,int i,int j){ int t = a[i]; a[i] = a[j]; a[j] = t;}//插入排序void insertion_sort(int *a,int len){ int i,j; if (len < 2) { return;

封装成类：package com.roc.algorithms.sort;/** * 插入排序 * * @author roc */public class InsertionSort { //交换数组元素 private static void swap(int[] a, int i, int j) { int t = a[i];

封装成函数：//交换数组元素void swap(int *a,int i,int j){ int t = a[i]; a[i] = a[j]; a[j] = t;}//希尔排序void shell_sort(int *a,int len){ int h=1,i,j; while(h<len/3) //寻找合适的间隔h {

封装成类：package com.roc.algorithms.sort;/** * 希尔排序 * * @author roc */public class ShellSort { //交换数组元素 private static void swap(int[] a, int i, int j) { int t = a[i]; a[i

封装成函数merge_sort_up_to_down（自顶向下方式）和merge_sort_down_to_up（自底向上方式）：#include //归并操作void merge(int *a,int *aux,int lo,int mid,int hi){ int i,j,k; for(k=lo; k<=hi; k++) { aux[k] =

封装成类：package com.roc.algorithms.sort;/** * 归并排序 * * @author roc */public class MergeSort { //自顶向下方式 public static void sortUpToDown(int[] a) { int[] aux = new int[a.length];

本算法主要解决动态连通性一类问题，这里尽量用精炼简洁的话来阐述。数据结构描述：有N个节点（索引0~N-1），可以查询节点数量可以连接两个节点可以查询两个节点是否连通算法大致设计思路：每个节点初始化为不同的整数标记通过一个辅助函数查询某个节点的标记值如果两节点标记相同，说明两节点是连通的抽象基类：class UnionFind{public:

封装成类：package com.roc.algorithms.sort;/** * 快速排序 * * @author roc */public class QuickSort { public static void sort(int[] a) { sort(a, 0, a.length - 1); } private static vo

封装成类：package com.roc.algorithms.sort;/** * 三向切分快速排序 * 适合有较多重复元素的排序算法 * * @author roc */public class ThreeWayQuickSort { public static void sort(int[] a) { sort(a, 0, a.length -

封装成函数：//快速排序void quick_sort(int *a,int len){ sort(a,0,len-1);}void sort(int *a,int lo,int hi){ int i,j,k; if(lo>=hi) { return; } k = partition(a,lo,hi); sort

封装成函数：//交换数组元素void swap(int *a,int i,int j){ int t = a[i]; a[i] = a[j]; a[j] = t;}//在lt之前的(lo~lt-1)都小于中间值//在gt之前的(gt+1~hi)都大于中间值//在lt~i-1的都等于中间值//在i~gt的都还不确定（最终i会大于gt，即不确定的将不复存在）

最近研究三角定位算法，研究了下怎样求两圆的交点，现给出求解方法：

数学求解原理请看：http://blog.youkuaiyun.com/qq245671051/article/details/52017403下面是golang代码实现：package mainimport ( "math")//代表一个点，包含横纵坐标type Point struct { X, Y float64}//代表一个圆，包含横纵坐标及半径

效果把某个字节或字节数组转换成字符串01的形式，一个字节用8个”0”或”1”字符表示。比如： byte(3) –> “00000011” []byte{1,2,3} –> “[00000001 00000010 00000011]” “[00000011 10000000]” –> []byte{0x3, 0x80}开源库 biu实际上我已经将其封装到一个开源库了(biu)，其中的一个功能就能

**注：**次幂n为整数，底数可以是整数、小数、矩阵等(只要能进行乘法运算的 举个求整数的n次方的例子(Go语言版)：``` gofunc pow(x, n int) int { ret := 1 // 结果初始为0次方的值，整数0次方为1。如果是矩阵，则为单元矩阵。 for n != 0 { if n%2 != 0 { ret = ret * x } n /= 2 x = x *

封装成类：/** * 选择排序 * * @author roc */public class SelectionSort { //交换数组元素 private static void swap(int[] a, int i, int j) { int t = a[i]; a[i] = a[j]; a[j] = t;

封装成函数：//交换数组元素void swap(int *a,int i,int j){ int t = a[i]; a[i] = a[j]; a[j] = t;}//选择排序void selection_sort(int *a,int len){ int m = len-1; //以免每次循环判断都运算 int i,j,k; fo

两种类似的方式：/** * 冒泡排序 * @author roc */public class BubbleSort { //交换数组元素 private static void swap(int[] a,int i,int j){ int t = a[i]; a[i] = a[j]; a[j] = t; }

封装成函数：//交换数组元素void swap(int *a,int i,int j){ int t = a[i]; a[i] = a[j]; a[j] = t;}//下沉（由上至下的堆有序化）void sink(int *a,int k,int N){ while (1) { int i = 2 * k; i

封装成类：package com.roc.algorithms.common;import java.util.Arrays;/** * 选出第k小元素、中位数、最小的k个元素(线性复杂度) * * @author roc */public class Select { //选出第k小元素，k为1~a.length public static int se

封装成函数：#include void swap(int *a,int i,int j){ int t = a[i]; a[i] = a[j]; a[j] = t;}int partition(int *a,int lo,int hi){ int i,j; i=lo; j=hi+1; while(1) {

封装成类：package com.roc.algorithms.search;/** * 二分法查找 * * @author roc */public class BinarySearch { /** * @param a 升序排列的数组 * @param k 待查找的整数 * @return 如果查到有就返回对应角标，没有就返回-1

封装成函数：//二分法查找//数组a是升序的，len为数组长度//k为待查找的整数//如果查到有就返回对应角标,//没有就返回-1int search(int *a,int len, int k){ int lo = 0, hi = len - 1; while (lo <= hi) { int m = (lo + hi) >> 1;

为简单起见，键值均为整型。定义接口(tree.go)：type Tree interface { Put(k, v int) //新增或修改 Get(k int) int //查询 Delete(k int) //删除 Size() int //树的大小 Min() int //最小键 DeleteMin() //删除最小键}二叉查找树(

封装成函数：//二分法查找//切片s是升序的//k为待查找的整数//如果查到有就返回对应角标,//没有就返回-1func BinarySearch(s []int, k int) int { lo, hi := 0, len(s)-1 for lo hi { m := (lo + hi) >> 1 if s[m] k { lo = m + 1 } else if s[m]

封装成函数：//选出第k小元素，k为1~len(s)func SelectKthMin(s []int, k int) int { k-- lo, hi := 0, len(s)-1 for { j := partition(s, lo, hi) if j k { lo = j + 1 } else if j > k { hi = j - 1 } else { r

封装成函数：//堆排序//s[0]不用，实际元素从角标1开始//父节点元素大于子节点元素//左子节点角标为2*k//右子节点角标为2*k+1//父节点角标为k/2func HeapSort(s []int) { N := len(s) - 1 //s[0]不用，实际元素数量和最后一个元素的角标都为N //构造堆 //如果给两个已构造好的堆添加一个共同父节点， //将新添加的节点作一次下

封装成函数：//三向切分快速排序func ThreeWayQuickSort(s []int) { sort3way(s, 0, len(s)-1)} //在lt之前的(lo~lt-1)都小于中间值//在gt之前的(gt+1~hi)都大于中间值//在lt~i-1的都等于中间值//在i~gt的都还不确定（最终i会大于gt，即不确定的将不复存在）func sort3way(s []int,

封装成函数：//快速排序func QuickSort(s []int) { sort(s, 0, len(s)-1)} func sort(s []int, lo, hi int) { if lo >= hi { return } k := partition(s, lo, hi) sort(s, lo, k) sort(s, k+1, hi)} func partition(s [

封装成函数：//自顶向下归并排序func MergeSortUpToDown(s []int) { aux := make([]int, len(s)) //辅助切片 mergeSortUpToDown(s, aux, 0, len(s)-1)} //自底向上归并排序func MergeSortDownToUp(s []int) { aux := make([]int, len(s))

封装成函数：package sort func ShellSort(a []int) { n := len(a) h := 1 for h n/3 { //寻找合适的间隔h h = 3*h + 1 } for h >= 1 { //将数组变为间隔h个元素有序 for i := h; i n; i++ { //间隔h插入排序 for j := i; j >= h &&

封装成函数：//插入排序func InsertionSort(s []int) { n := len(s) if n 2 { return } for i := 1; i n; i++ { for j := i; j > 0 && s[j] s[j - 1]; j-- { swap(s, j, j - 1) } }} func swap(slice []int, i i

本算法主要解决动态连通性一类问题，这里尽量用精炼简洁的话来阐述。数据结构描述：有N个节点（索引0~N-1），可以查询节点数量可以连接两个节点可以查询两个节点是否连通算法大致设计思路：每个节点初始化为不同的整数标记通过一个辅助函数查询某个节点的标记值如果两节点标记相同，说明两节点是连通的用一个包专门处理union-find算法(unionfind)定义

封装成函数：//交换数组元素func swap(slice []int, i int, j int) { slice[i], slice[j] = slice[j], slice[i]} //选择排序func SelectionSort(s []int) { l := len(s) //以免每次循环判断都运算 m := len(s)-1 for i:=0;im;i++ { k:

有两种相似的方式：func swap(slice []int, i int, j int) { slice[i], slice[j] = slice[j], slice[i]} //第一种冒泡排序func BubbleSort1(slice []int) { length := len(slice) max := length - 1 for i := 0;

// 求最大连续子数组和func MaxSubArray(arr []int) int { currSum := 0 maxSum := arr[0] for _, v := range arr { if currSum > 0 { currSum += v } else { currSum =