2017年01月_一缕阳光a

原创两路归并排序

两路归并排序（升序排列） (平均/最差)时间复杂度O(NlogN)将两个有序的单链表合并为一个有序的单链表，默认是按升序排列的。合并操作是非常适合用递归来完成的一类操作，递归实现将会比迭代实现更加清晰且易于理解。尽管如此，你可能也不愿意使用递归来实现这个操作，因为递归方法所使用的栈空间与链表的长度成正比。部分关键代码如下：typedef struct _Node_t

2017-01-25 23:06:48 2781

原创 <java并发编程实战>阅读总结(b)

5、Executor框架Executor框架是并发集合java.util.concurrent中的一个成员。Executor为灵活且强大的异步任务执行框架提供了基础，还提供了对生命周期的支持，以及统计信息、应用管理机制和性能监视等机制。Executor 最早是为了解决生产者-消费者模式而引入的。提交任务相当是生产者，执行任务相当是消费者。线程池：(翻译的文档)：线程池和工作

2017-01-24 23:11:52 311

原创 <java并发编程实战>阅读总结(a)

锁(lock)与volatile(1)、隐式锁，java提供了强制原子性的内置锁机制：synchronized块或synchronized方法。操作共享状态的复合操作必须是原子的，以避免竞态条件，比如读-改-写操作和检查再运行操作。复合操作会在完整的运行期占有锁，以确保其行为为原子的。不管是同步代码块还是同步方法，每次只有一个线程可以进入，如果其他线程试图进入（不管是同一同步块还是

2017-01-24 17:51:57 566

原创 String、StringBuffer与StringBuilder之间区别

最近腾出时间来了，将1年前学习的一些东西整理出来String、StringBuffer与StringBuilder这三个类用在字符串处理中，那么他们到底有什么优、缺点，什么时候该用谁呢？下面我们从以下几点说明一下1.三者在平均效率方面的比较：StringBuilder > StringBuffer > String　　　　String：字符串常量，只能被创建或销毁。

2017-01-24 14:36:10 231

转载多线程的异常捕捉

为什么要单独讲多线程的异常捕捉呢？先看个例子：public class ThreadException implements Runnable{ @Override public void run() { throw new RuntimeException(); } //现象：控制台打印出异常信息，并运行一段时间后才停止 pub

2017-01-22 18:28:13 302

原创多线程(三)

38) 如何在Java中创建Immutable对象？要创建不可变类，要实现下面几个步骤：(1)、通过构造方法初始化所有成员；(2)、对变量不要提供set方法；(3)、将所有的成员声明为私有的，这样就不允许直接访问这些成员；(4)、在get方法中，不要直接返回对象本身，而是克隆对象，并返回对象的拷贝。39） Java中的ReadWriteLock是什么？一般而言，

2017-01-20 13:27:54 214

原创多线程(二)

17) 为什么wait()和notify()方法要在同步块中调用？Java API强制要求这样做，否则会抛出IllegalMonitorStateException异常。还有一个原因是为了避免wait和notify之间产生竞态条件。18) 为什么你应该在循环中检查等待条件?防止处于等待状态的线程收到错误的唤醒消息。如果不在循环中检查等待条件，程序就会在没有满足结束条件的情况下退

2017-01-20 11:28:23 312

原创多线程(一)

1) 什么是线程？线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒2) 线程和进程有什么区别？进程是一个独立的具有一定功能的程序，关于某个集合的一次执行过程。线程是进程的

2017-01-19 13:28:15 245

转载 equals()与==的区别

“==”比较两个变量本身的值，即两个对象在内存中的首地址。“equals()”比较字符串中所包含的内容是否相同。比如：String s1,s2,s3 = "abc", s4 ="abc" ;s1 = new String("abc");s2 = new String("abc");那么：s1==s2 是 false //两个变量的内存地址不一

2017-01-19 12:36:18 211

原创单例模式(C++)

其他写法的单例模式就不多说了，主要说下多线程同时执行的情况下的单例模式。为了多线程执行时的安全性，该单例模式使用了锁的机制，防止数据一边在“读”，一边在“写”，导致数据不完整。在本人做的一个海外的项目时就遇到了这个问题，当时查了很久，熬了2个通宵，最后查到是多线程并发执行时对数据库中的数据没有加锁同步导致的。跑题了，接着下面讲述Ｃ++中的单例模式的使用。单例模式只有一个实例

2017-01-19 11:28:38 232

转载 JVM GC调优总结 -Xms -Xmx -Xmn -Xss

堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。典型设置：java -Xmx3550m -Xms355

2017-01-19 11:11:18 1456

转载生产者-消费者模式

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产

2017-01-18 19:36:20 299

原创责任链模式

设计模式是前人、大牛等在实际编程中对遇到的问题解决方案的抽象。描述：将多个对象连成一条链，并沿着这条链传递请求，直到有对象处理它。应用：程序运行时抛出异常，该异常会一直向上抛出直到遇到处理它的代码为止。1.责任链模式在编程中的小体现，看下面的情况 switch (a) { case 1: //... break; case 2: //...

2017-01-18 18:38:18 324

转载简单工厂模式+工厂方法模式

在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助功能的对象。在这些情况,新对象的建立就是一个 “过程”，不仅是一个操作，像一部

2017-01-18 15:50:01 300

原创单例模式(Java)

该单例模式考虑到了 "双检锁"的情况单例模式只有一个实例，节省了资源，提高了效率。public class Singleton { private Singleton() {} private volatile static Singleton instance; public static Singleton getInstance() { if (

2017-01-18 14:39:24 328

原创求2个数的最大公约数

求2个数的最大公约数该方法只适用于部分数int gongyueshu(int m, int n){ if ((0 == m) || (0 == n)) { return 0; } while (n)//考虑到n是负数 { int temp = n; n = m % n;

2017-01-18 14:33:50 294

原创排序算法之希尔排序(Java)

希尔排序平均时间复杂度：O(nlogn) 不稳定的排序算法v[0]与v[0+n/2]比较，v[1]与v[1+n/2]比较，v[2]与v[2+n/2]比较，小的放到前面，以此类推..............关键部分代码如下：public static void shell_sort(int[] data){ int group = 0; int i = 0

2017-01-18 14:25:08 206

原创排序算法之简单插入法排序(Java)

简单插入排序时间复杂度 O(n*n) 稳定的排序算法逐一取出元素，在已排好的元素序列中从后向前扫描，插入到适当的位置部分代码如下： public static void insert_sort(int[] data) { int i= 0; int j = 0; int len = 0; int

2017-01-18 14:21:11 853

原创排序算法之选择法排序(Java)

选择排序时间复杂度 O(n*n) 不稳定的排序算法思想是：每一趟从待排序的数据元素中选出最小的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。下面是关键部分代码：public static void select_sort(int[] data){ int i = 0, j = 0, k = 0; int len = 0, tmp

2017-01-18 13:59:24 526

原创排序算法之快速排序(Java)

快速排序平均时间复杂度 O(NlogN) 最差时间复杂度O(N*N) 不稳定它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 /** * 1．先从数列中取出一个数作为基准数。

2017-01-18 13:35:36 175

原创排序算法之两路归并排序(Java)

将2个有序的数组合并为一个有序的数组时间复杂度为O(nlogn)默认是按升序进行排序：public class MergeSort { public static int[] sort(int[] data, int low, int high) { int mid = (low + high) / 2; if (lo

2017-01-18 12:58:30 898

原创求出2个字符串中的最大公共子串

给定字符串A和B,输出A和B中的最大公共子串。比如A="aocdfe" B="pmcdfa" 则输出"cdf"void commonstring(char *str1, char *str2, char *maxSubstr){ int i = 0, j = 0, k = 1, maxPos = -1, maxLen = 0; if ((NULL == str1)

2017-01-18 12:57:18 565

原创分解成质因数

分解成质因数 (如435234=251*17*17*3*2)void prim(int m) { int n = 2; if (m > n) { while (m%n != 0) { n++; } m /= n; prim(m

2017-01-18 12:55:31 1187

原创将一个数组里面的奇数全部排在前面，偶数排在后面

将一个数组里面的奇数全部排在前面，偶数排在后面void paixu(int dest[], int n, int src[]){ int i = 0, m = n-1, k = 0; if (0 >= n) { return ; } for (i = 0; i < n; i++) { if (

2017-01-18 12:54:22 8282

原创逆转一个链表

在一个list中，我们先让头结点的next域指向结点2，再让结点1的next域指向结点3，最后将结点2的next域指向结点1，就完成了第一次交换，顺序就变成了Header-结点2-结点1-结点3-结点4-NULLtypedef struct _list_t{ struct _list_t *next; int data;}list;void reverse_l

2017-01-17 20:41:18 292

原创二分法查找(C/C++)

当数据量很大适宜采用该方法。采用二分法查找时，数据需是排好序的,默认是按升序排好的。时间复杂度：O(logn)集合中的set和map中使用二分法进行查找的。int BiSearch(char *str, int n, char find) //返回值是：下标{ int low = 0, mid = 0, upper = n-1; if ((NULL

2017-01-17 20:21:13 682

原创排序算法之选择法排序(C/C++)

简单选择排序的基本思想：第1趟，在待排序记录r[1]~r[n]中选出最小的记录，将它与r[1]交换；第2趟，在待排序记录r[2]~r[n]中选出最小的记录，将它与r[2]交换；以此类推，第i趟在待排序记录r[i]~r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕void select_sort(int a[], int n){ int i =

2017-01-17 20:19:05 21581

原创排序算法之希尔排序(C/C++)

从第一个数开始，判断第一个数和n/2那个数的大小，如果v[0]大于v[n/2]就交换，1与3比较，2与4比较，3与5比较...............void shell_sort(char *str, int len){ int group = 0, i = 0, j = 0, temp = 0; if ((NULL == str) || (0 >= len))

2017-01-17 20:11:41 302

原创 strncat()

将源字符串的前count个字符拷贝到目的字符串中char *strncat(char *dest, const char *src, size_t count){ assert((NULL != dest) && (NULL != dsrc)); char *cp = dest; if (0 == count)//返回原来的 { r

2017-01-17 19:58:06 659

原创 strncpy()

char *strncpy(char *dest, const char *src, unsigned int count){ assert((NULL != dest) && (NULL != dsrc)); char *ret = dest; if (0 == count) { return dest; } whi

2017-01-17 19:53:41 348

原创 strcmp()

比较2个字符串，返回2个字符串的差值int strcmp(const char *str1, const char *str2){ assert((NULL != str1) && (NULL != str2)); while(*str1 && *str2 && (*str1 == *str2)) { str1++; str2++; }

2017-01-17 19:51:37 464

原创 strcat()

把源字符串连接到目的字符串的后面。目的字符串的长度要足够长char *strcat(char *dest, const char *src){ assert((NULL != dest) && (NULL != src)); char *cp = dest; while (*cp != '\0') { cp++; } while ((*cp++

2017-01-17 19:50:36 339

原创 memmove()

memcpy()只是memmove()的一个子集memcpy()在执行内存重叠的情况下时，就会发生错误，而memmove()不会void *memmove(void *dest, const void *src, size_t count){ assert((dest!=0)&&(src!=0)); unsigned char *pdest =(char * )d

2017-01-17 19:48:47 6032

原创 memcpy()

memcpy()：把一块内存src的前count个字符复制到目的内存dest中memcpy()用于对一块连续内存的拷贝，可用于对任何类型的数据拷贝，在拷贝时，需要指出要拷贝数据的大小void *memcpy(void *dest, const void *src, unsigned int count){ assert((NULL != dest) && (NULL

2017-01-17 19:39:06 373

原创 m进制转换为n进制

m进制转换为n进制void m2n(unsigned char *dest, unsigned int n, unsigned char *src, unsigned int m){ unsigned char ch, *p = dest - 1; unsigned int i = 0; if ((NULL == dest) || (NULL == src)

2017-01-17 19:36:16 777

原创一个单向链表，输出该链表中倒数第k个结点，链表的倒数第0个结点为链表的尾指针

输入一个单向链表，输出该链表中倒数第k个结点。链表的倒数第0个结点为链表的尾指针typedef struct _node_t{ struct _list_t *next; int data;}Node;Node *list_k_node(Node * head, int k) { Node *p=head, *pk=head; if (NULL ==

2017-01-17 19:32:53 686

原创判断一个链表是否为循环单链表

判断一个链表是否为循环单链表：#设置两个指针(fast, slow)，slow步长为1，fast步长为2，大概的思路如下：如果链表为循环单链表，则fast与slow必定相遇。如果链表不为循环单链表，则fast必定先指向NULL。int IsLoopList(list *head){ list *s = head->next; //慢指针

2017-01-17 18:48:33 1949

原创判断一个单链表中是否存在环

#判断一个单链表中是否存在环。#设置两个指针(fast, slow)，初始值都指向头，slow每次前进1步，fast每次前进2步，大概的思路如下：如果链表存在环，则fast必定先进入环，而slow后进入环，两个指针必定相遇。如果链表不存在环，则fast必定先指向NULL，而slow后指向NULL。如果存在环，则返回1；否则，返回0int IsExit

2017-01-17 18:46:38 2751

原创一个整数转换成字符串(C/C++自己写的算法)

自己写的一个算法：将一个int型数转换为stringchar *itoa(int num, char *str){ assert(NULL != str); int i=1, j=0; if (num < 0) { str[j++]='-'; num = (-1)*num; } if (0 == nu

2017-01-17 18:27:01 1353

原创汉诺塔问题

汉诺塔的问题的由来就不用多说了，下面讲述主要的算法以及思想：若要将n个盘子由A移动到B，需要三个步骤1.先将n-1个盘子由A，移动到B(借助C); #h(n-1,a,c,b)2.再将剩下一个盘子由A移动到C(借助B);#h(1,a,b,c)3.将B中的n-1个盘子移动到C(借助A); #h(n-1,b,a,c)大概的算法如下：void hanoi(int n

2017-01-17 17:14:31 218

空空如也

空空如也