算法分析入门系列(三) 动态规划算法
发表Code

算法分析入门系列(三) 动态规划算法

作业排程问题

问题描述

Automobile factory with two assembly lines(汽车厂两条装配线)

– Each line has n stations: S1,1, . . . , S1,n and S2,1, . . . , S2,n(每条装

配线有n个工序站台)

– Corresponding stations S1, j and S2, j perform the same function

but can take different amounts of time a1, j and a2, j (每条装配线的

第j个站台的功能相同,但是效率不一致)

– Entry times e1 and e2 and exit times x1 and x2(上线和下线时间)

阅读更多
算法分析入门系列(四) 最短路径算法
算法分析入门系列(二) 分治算法
算法分析入门系列(一) 排序算法
发表Code

算法分析入门系列(一) 排序算法

排序算法

main函数代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
public static void main(String[] args) {
    int max = 10;
    System.out.println("插入排序-------------------------------------");
    int[] num = randomCreate(max);
    printResult(num);
    Long bt = System.nanoTime();
    int[] temp1 = insertSort(num);
    Long et = System.nanoTime();
    System.out.println("排序用时：" + (et - bt + ""));
    printResult(temp1);


    System.out.println("合并排序-------------------------------------");
    int[] temp4 = randomCreate(max);
    printResult(temp4);
    Long bt2 = System.nanoTime();
    mergeSort(temp4);
    Long et2 = System.nanoTime();
    System.out.println("排序用时：" + (et2 - bt2 + ""));
    printResult(temp4);


    System.out.println("快速排序-------------------------------------");
    int[] temp5 = randomCreate(max);
    printResult(temp5);
    Long bt3 = System.nanoTime();
    quickSort(temp5, 0, temp5.length - 1, false);
    Long et3 = System.nanoTime();
    System.out.println("排序用时：" + (et3 - bt3 + ""));
    printResult(temp5);

    System.out.println("随机化快速排序--------------------------------");
    int[] temp9 = randomCreate(max);
    printResult(temp9);
    Long bt7 = System.nanoTime();
    quickSort(temp9, 0, temp9.length - 1, true);
    Long et7 = System.nanoTime();
    System.out.println("排序用时：" + (et2 - bt2 + ""));
    printResult(temp9);


    System.out.println("桶排序---------------------------------------");
    int[] temp6 = randomCreate(max);
    printResult(temp6);
    Long bt4 = System.nanoTime();
    temp6 = bucketSort(temp6, max);
    Long et4 = System.nanoTime();
    System.out.println("排序用时：" + (et4 - bt4 + ""));
    printResult(temp6);

    System.out.println("计数排序-------------------------------------");
    int[] temp7 = randomCreate(max);
    printResult(temp7);
    Long bt5 = System.nanoTime();
    temp7 = countSort(temp7);
    Long et5 = System.nanoTime();
    System.out.println("排序用时：" + (et5 - bt5 + ""));
    printResult(temp7);

    System.out.println("基数排序-------------------------------------");
    int[] temp8 = randomCreate(max);
    printResult(temp8);
    Long bt6 = System.nanoTime();
    radixSort(temp8, (max + "").length());
    Long et6 = System.nanoTime();
    System.out.println("排序用时：" + (et6 - bt6 + ""));
    printResult(temp8);
    System.out.println("---------------------------------------------");

}
阅读更多
如何制作一个简单的网络爬虫？nodejs实现
发表Code

如何制作一个简单的网络爬虫？nodejs实现

接下来有打算每半个月写一点东西，不然写东西的频率太低就会造成正反馈，产出越来越少了。

这段时间一共做了三个爬虫：

  • 爬取丁香园的疫情数据
  • 爬取联想的虚拟货币乐豆
  • 第三个跟第一个类似，不过工作量大一点
阅读更多
完成经典算法的C语言实现
数据结构入门？这一篇就够了
发表Code

堆排序

[scode type=”yellow”]堆排序思路[/scode]

  1. 将传入的数组看作是一个没有完成的堆
  2. 将堆整理排序成一个大顶堆
  3. 将大顶堆最大的元素，也就是堆顶，与这个堆最后的元素进行交换
  4. 然后视这个除刚刚交换的那个元素外的数组为一个堆，对它进行大顶堆标准检查，并将其整理成一个大顶堆
  5. 有一点需要注意的是每次交换之后接下来需要接着排序的堆的大小需要减一！
  6. 为了减小空间的占用，可以视交换到末尾的元素为已经出堆的元素，仅仅对这些元素之前的数组进行大顶堆检查。

[scode type=”yellow”]大顶堆概念[/scode]

阅读更多
发表Code

散列表相关的几个算法

根据算法图解一书写的两个算法：广度优先算法以及狄克斯特拉算法：

散列表

散列表在Python中也称作字典，通常的定义方式为： name = dict()

阅读更多
关注我

链接

分类

最新文章

归档

×