- 博客(54)
- 资源 (1)
- 收藏
- 关注
RSS订阅原创 算法代码实现之三向切分快速排序，C/C++实现
封装成函数：//交换数组元素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，即不确定的将不复存在）
2016-02-29 22:08:48
804
原创 算法代码实现之三向切分快速排序，Java实现
封装成类：package com.roc.algorithms.sort;/** * 三向切分快速排序 * 适合有较多重复元素的排序算法 * * @author roc */public class ThreeWayQuickSort { public static void sort(int[] a) { sort(a, 0, a.length -
2016-02-29 21:46:54
1711
原创 算法代码实现之三向切分快速排序，Golang(Go语言)实现
封装成函数：//三向切分快速排序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,
2016-02-29 21:34:47
988
原创 算法代码实现之快速排序，C/C++实现
封装成函数：//快速排序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
2016-02-29 19:49:15
563
原创 算法代码实现之快速排序，Java实现
封装成类：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
2016-02-29 19:34:32
645
原创 算法代码实现之快速排序，Golang(Go语言)实现
封装成函数：//快速排序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 [
2016-02-29 19:18:33
1178
原创 算法代码实现之Union-Find，C++实现，quick-find、quick-union、加权quick-union(附带路径压缩优化)
本算法主要解决动态连通性一类问题，这里尽量用精炼简洁的话来阐述。数据结构描述：有N个节点（索引0~N-1），可以查询节点数量可以连接两个节点可以查询两个节点是否连通算法大致设计思路：每个节点初始化为不同的整数标记通过一个辅助函数查询某个节点的标记值如果两节点标记相同，说明两节点是连通的抽象基类：class UnionFind{public:
2016-02-29 09:49:08
2667
原创 算法代码实现之归并排序，Java实现，自顶向下与自底向上两种方式
封装成类：package com.roc.algorithms.sort;/** * 归并排序 * * @author roc */public class MergeSort { //自顶向下方式 public static void sortUpToDown(int[] a) { int[] aux = new int[a.length];
2016-02-28 22:18:43
1493
原创 算法代码实现之归并排序，C/C++实现，自顶向下与自底向上两种方式
封装成函数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] =
2016-02-28 22:05:53
2521
原创 算法代码实现之归并排序，Golang(Go语言)实现，自顶向下与自底向上两种方式
封装成函数：//自顶向下归并排序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))
2016-02-28 21:23:56
1739
原创 算法代码实现之希尔排序，Java实现
封装成类：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
2016-02-28 16:26:40
1652
原创 算法代码实现之希尔排序，C/C++实现
封装成函数：//交换数组元素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 {
2016-02-28 16:20:40
810
原创 算法代码实现之希尔排序，Golang(Go语言)实现
封装成函数：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 &&
2016-02-28 16:12:28
1187
原创 算法代码实现之插入排序，Java实现
封装成类：package com.roc.algorithms.sort;/** * 插入排序 * * @author roc */public class InsertionSort { //交换数组元素 private static void swap(int[] a, int i, int j) { int t = a[i];
2016-02-28 15:49:46
485
原创 算法代码实现之插入排序，C/C++实现
封装成函数：//交换数组元素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;
2016-02-28 15:42:54
499
原创 算法代码实现之插入排序，Golang(Go语言)实现
封装成函数：//插入排序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
2016-02-28 15:33:23
903
原创 算法代码实现之Union-Find，Java实现，quick-find、quick-union、加权quick-union(附带路径压缩优化)
本算法主要解决动态连通性一类问题，这里尽量用精炼简洁的话来阐述。数据结构描述：有N个节点（索引0~N-1），可以查询节点数量可以连接两个节点可以查询两个节点是否连通算法大致设计思路：每个节点初始化为不同的整数标记通过一个辅助函数查询某个节点的标记值如果两节点标记相同，说明两节点是连通的抽象基类：package com.roc.algorithms.u
2016-02-28 14:48:47
2135
原创 算法代码实现之Union-Find，Golang(Go语言)实现，quick-find、quick-union、加权quick-union(附带路径压缩优化)
本算法主要解决动态连通性一类问题，这里尽量用精炼简洁的话来阐述。数据结构描述：有N个节点（索引0~N-1），可以查询节点数量可以连接两个节点可以查询两个节点是否连通算法大致设计思路：每个节点初始化为不同的整数标记通过一个辅助函数查询某个节点的标记值如果两节点标记相同，说明两节点是连通的用一个包专门处理union-find算法(unionfind)定义
2016-02-28 12:34:27
2042
原创 算法代码实现之选择排序，Java实现
封装成类：/** * 选择排序 * * @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;
2016-02-27 21:20:24
529
原创 算法代码实现之选择排序，C/C++ 实现
封装成函数：//交换数组元素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
2016-02-27 21:14:06
829
1
原创 算法代码实现之选择排序，Golang(Go语言)实现
封装成函数：//交换数组元素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:
2016-02-27 21:03:34
1049
原创 算法代码实现之冒泡排序，Java实现
两种类似的方式：/** * 冒泡排序 * @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; }
2016-02-27 20:45:31
1332
原创 算法代码实现之冒泡排序，C/C++ 实现
两种类似的方式：#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
2016-02-27 20:28:12
3219
原创 算法代码实现之冒泡排序，Golang(Go语言)实现
有两种相似的方式：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;
2016-02-27 19:59:39
1185
原创 Golang(Go语言)读取文件基本用法
需要用到os和bufio包import "os"import "bufio"用os.Open打开一个文件，用bufio.NewReader来读取文件file, err := os.Open("input.dat")if err!= nil { fmt.Println("failed to open") return}defer file.Close()reade
2016-02-24 21:34:42
3684
原创 Golang(Go语言)代码技巧之数组(array)和切片(slice)
去掉最后n个元素line = line[:len(line)-n]两种遍历方式for i:=0;ilen(line);i++{ // ...=line[i]}for index,value:=range line { //...}二维数组中查询某个值是否存在found := falseLABEL:for row :
2016-02-24 21:33:28
5328
原创 Golang(Go语言)代码技巧之字符串(string)
改变字符串中的某些字符str := "hello roc"bytes := []byte(str)bytes[1] = 'a'str = string(bytes) //str == "hallo roc"截取子串substr := str[n:m] //截取从索引n到m-1的子串遍历字符串//for遍历，此方式只能遍历存放ASCII//编码
2016-02-24 21:32:55
24029
原创 Golang(Go语言)内置函数之copy用法
该函数主要是切片（slice）的拷贝，不支持数组将第二个slice里的元素拷贝到第一个slice里，拷贝的长度为两个slice中长度较小的长度值示例：s := []int{1,2,3}fmt.Println(s) //[1 2 3]copy(s,[]int{4,5,6,7,8,9})fmt.Println(s) //[4 5 6]有一种特殊用法，将字符串当成
2016-02-24 21:32:16
21123
原创 Golang(Go语言)内置函数之append
append主要用于给某个切片（slice）追加元素如果该切片存储空间（cap）足够，就直接追加，长度（len）变长；如果空间不足，就会重新开辟内存，并将之前的元素和新的元素一同拷贝进去第一个参数为切片，后面是该切片存储元素类型的可变参数 基础用法：slice := append([]int{1,2,3},4,5,6)fmt.Println(slice) //[1 2 3
2016-02-23 14:20:50
52698
3
原创 Golang(Go语言)中append函数返回值必须有变量接收的原因探究
append函数返回更新后的slice（长度和容量可能会变），必须重新用slice的变量接收，不然无法编译通过 为了弄明白为什么，首先我们需要清楚几件事：slice的底层是数组，一片连续的内存，slice变量只是存储该slice在底层数组的起始位置、结束位置以及容量。它的长度可以通过起始位置和结束位置算出来，容量也可以通过起点位置到底层数组的末端位置的长度
2016-02-23 14:17:23
6804
原创 golang语法总结（二十二）：接口interface
类型关键字为interface不需要显式声明实现某个接口，只要实现相关方法就实现了接口 基本示例：type Person interface { Name() string}type Student struct { name string}func (s Student)Name() string { return s.name}func main() { var p
2016-02-23 14:15:43
1632
原创 golang语法总结（二十一）：方法method
Go不像其它面相对象语言一样可以写个class，然后在class里面写一堆方法，但是它也很巧妙的实现了这种效果，我们只需要在普通函数前面加个接受者（receiver，写在函数名前面的括号里面），这样编译器就知道这个函数（方法）属于哪个struct了。 下面是简单示例：type A struct { Name string} func (a A)foo() { //接收者
2016-02-23 14:14:53
4193
1
原创 golang语法总结（二十）：struct组合
Go的struct可以嵌入组合其它struct，有点像是继承，下面是示例：type human struct { Sex int}type person struct { human //嵌入结构，只需要写出结构类型 Name string Age int}func main() { a := person{ Name:"cpwl", Age : 21, human : huma
2016-02-22 18:33:32
6713
原创 golang语法总结（十九）：结构struct
Go没有class，也没有继承机制，只能定义结构体，但是功能还是很强大。本文先演示下它的基本用法。简单使用示例：type person struct { Name string Age int}func main() { a := person{ //声明的时候可以赋初始值，也可以不要 Name:"cpwl", Age : 21, } a.Name
2016-02-22 18:32:36
2570
原创 golang语法总结（十八）：处理异常
Go语言没有提供像其它语言一样的try catch的异常与捕获机制，可以用defer、panic、recover代替。defer的语句或函数在当前函数执行完之后再执行，先defer的后执行，后defer的先执行。当程序发生严重错误的时候defer也能够执行。有点类似其它语言的析构函数调用panic来制造一个异常调用recover来获取异常信息func main(){
2016-02-22 14:09:36
1710
原创 golang语法总结（十七）：函数
用关键字func定义可以有多个返回值func main(){ f1() //f1 a,b := f2(1,1.2) fmt.Println(a,b) //4.34 2 c,d,e := f3() fmt.Println(c,d,e) //1 2 3 f4("OK",1,2,3,4) //OK [1 2 3 4] f5() //hello world f := f6(2) fmt.P
2016-02-22 14:06:03
1040
原创 golang语法总结（十六）：map
相当于其它语言的哈希表或字典，key-value形式存储数据key必须是支持==和!=比较运算的类型，不能是函数、map或slicevar m1 map[int]stringm1 = make(map[int]string)fmt.Println(m1) //map[]var m2 map[int]string = make(map[int]string)m2[1] = "OK
2016-02-22 14:04:01
1081
原创 golang语法总结（十五）：数组array与切片slice
数组 数组定义格式示例：var a [2]intfmt.Println(a)b := [2]int{2,3}fmt.Println(b)输出：[0 0][2 3] 还可以省略数组长度，编译器自动推算：a := [...]int{5,6,7,8} 还可以使用索引初始化：a := [...]i
2016-02-22 14:02:32
4527
原创 golang语法总结（十四）：跳转语句goto、break、continue
和其它许多语言用法大致一样，三种语法支持配合标签使用，标签区分大小写gotopackage main import "fmt" func main() { var i int = 1 if i 10 { goto LABEL } fmt.Println("before label") LABEL: fmt.Println("after label"
2016-02-22 13:58:26
7535
原创 golang语法总结（十三）：选择语句switch
条件语句可以使用任何类型或表达式，甚至不填不需要写break，一旦条件符合自动终止，如果希望继续执行下一个case，需使用fallthrough支持初始化表达式，右侧跟分号var a int = 1switch {case a>=1: fmt.Println("a>=1")case a>=0: fmt.Println("a>=0")}var a int =
2016-02-22 13:44:46
3240
搭建Spring4+Spring MVC web工程的最佳实践 源码.zip
2015-08-02
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人