http://localhost/phnix2/confirm.html?1=1&CustomerName=%ba%c3%b5%c4&tel=4444444&phone=33333333&mail=333333&CustomerAddress=%bc%d2%cd%a5%c8%cb&Remark=%bc%d2%cd%a5%c8%cb&CustomerId=51
URL传到前台后，前台js利用unescapte等方法均得不到中文。
解决方法：
后台：项目添加引用 Microsoft.Jscript
利用Microsoft.JScript.GlobalObject.escape(URL); 进行编码
前台利用unescape解码
1,商务通存数据，一种方式是存放到数据库中，客户的录入的信息存放数据库，然后客服端定时读取。这种的频繁对数据库的读写，且数据在磁盘上，速度、效率很有影响。另一种方式是在内存中设置一共享区如建立一static List集合，客户端向里面存，客服取，共同维护这一共享区，然后定时将此共享区的内容存入数据库即可。
至于客服端与服务器进行静态类共享的问题（即客服端与服务器共享服务器内存），可以利用web service来解决。在客户端点应用程序中添加服务器端的webservice,会自动引用服务器的命名空间，然后直接使用类即可。因为此类指定静态的，故做到了共享。 可参见PowerTalk的聊天信息存读方式。
即共享区用：static + webservice构造，static负责共享，webservice负责同一
Web Service本身其实是在实现应用程序间的通信。
客户端的概念是调用服务器上的远程过程，通常方式为实例化一个远程对象并调用其方法和属性。：服务器暴露出远程对象的接口，客户端就好像在本地使用的这些对象的接口一样，这样就隐藏了底层的信息，客户端也就根本不需要知道对象是在哪台机器上。
2, 将数据存放到内存中定时转储的方式属于NOSQL,代表之一Redis
Redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)和zset(有序集合)。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。
comm100
注册一个编号，可以新建多个客服。支持文本和语音聊天，客服转接和加入对话 ，监控访客动态，主动抓住客户等。还开以开论坛、知识库，关键是开源，免费的。
效果如下：
客户界面（可定制）：
信息来时提醒：
客服界面：
关键点是将不变化的东西固定下来，避免重复计算。设计表时，将不依赖外部数据，可直接得出的部分提取出来，方便查询。
有一快递A，快递价格递增，价格表如下：
重量(kg) 费用(元)
0-1 6
1-5 3/kg
5-10 2/kg
10-9999 1/kg
同时有一快递B，直接按公斤给价格，价格表如下：
0-1 6
1-5 16
5-10 24
10-9999 30
设计一table,将两种的价格表录入系统，并给出查询物品重量为n时的快递价格。
思路：快递A价格递增，计算时要考虑他之前物重范围相加。而B就相对简单，直接select取出。而价格表存放到同一表中，就要考虑容纳上面的两种特性。设计表如下：
快递公司 重量下限 重量上限 费用 子范围费用 （注：用附加费用存储比它小的范围的数据）
表数据存储为：
快递公司 重量下限 重量上限 费用 子范围费用
A 0 1 6 0
A 1 5 3 6 (直接给出前一范围的价格)
A 5 10 2 18
A 10 9999 1 28
B 0 1 6 0
B 1 5 16 0
B 5 10 24 0
B 10 9999 30 0
当外部传入快递公司为@X，物重为@weight时求其快递价格，可用如下方式：
SELECT CASE(附加费用) WHEN 0 THEN 费用 ELSE 子范围费用 + （n – 重量下限） * 费用
FROM 快递费用表
WHERE 快递公司 = @X
AND @weight BETWEEN 重量下限 AND 重量上限
72法则
假设以年利率r%投资一笔钱y年，如果r*y=72,那么你的投资差不多会翻倍。
即：增长率乘以增长次数若为72，那么数字翻倍。
原理：（1+ x）的y次方 = 2
y= ln2 / ln(1+x) ; ln2 = 0.69, ln(1+x) = x (泰勒公式),
故有：y= 0.69/x 即：xy = 0.69 , 0.69不易估算，换成70,72。之所以选用72，是因为它有较多因数，容易被整除，更方便计算。它的因数有1、2、3、4、6、8、9、12和它本身。
具体例子：
以年利率6%投资1000美元12年，可得到约2000美元（实际数字是2012美元）
以年利率8%投资1000美元9年，可得到约2000美元（实际数字式1999美元）
假设一个指数程序解决规模为n=40的问题需要10秒的时间，并且n每增加1运行时间就增加12%，问当我们把n=100的时候，大约需要多少运行时间？
根据72法则，n每增加6运行时间翻倍，那么当n增加60，运行时间增加为原来的2^10≈1000倍。因此，n=100时，大约需要10 000秒（2~3个小时）。
联合国估算1998年的世界人口为59亿，年增长率为1.33%。如果按照这个速率下去，到2050年人口会是多少？
2050-1998=52； 52*1.33≈70
因此根据72法则，2050年人口约为59*2=118亿。
出处：（http://www.cnblogs.com/yjf512/）
1M = 1024k
1K = 1024bit
1bit = 8位
一个整数占32位(4bit)，那么1M共可存放的整数个数为：1024*1024/4=262144个
题目：一个最多包含n个正整数的文件，每个数都小于n，其中n=10^7,且所有正整数都不重复。求如何将这n个正整数升序排列。
约束：最多有1MB的内存空间可用，有充足的磁盘存储空间。
直接读取所有文件入内存进行排序是不现实的，因为最多有1MB空间，最大可存放的数字是262144个
，可以分段取：从头到尾一段一段的取数据，在0-250000的放入内存并排序输出
从头到尾一段一段的取数据， 在250000-500000的放入内存并输出
从头到尾一段一段的取数据， 在500000-750000的放入内存并输出
从头到尾一段一段的取数据， 在750000-1000000的放入内存并输出
位图法排序:hash对应
定义一字符串，长度为10^7,初始每位为0，每位的顺序对应每个数字，分段读入数字，将对应位设置为1，
如：对于数字3，将此字符串的第三位设置为1即可。
然后输出为1的位数即可，不需排序。
与上边的方法相比，上边的方法要40次全文件扫描，而此方法仅需一次，并用结果不用排序
以空间换时间。
应用范围：1，知道上限。2，数字没有重复
推广：
给40亿个不重复的unsigned int的整数，没排过序的，然后再给一个数，如何快速判断这个数是否在那40亿个数当中
unsign int范围为0~2^32-1(4294967295≈5*10^9) 使用位图hash对应5*10^9/8/10^3/10^3 = 625MB.
1. 我们使用625M的字符串。每一位设置为0.
2. 将40亿个unsign int 遍历一遍。使用位图法将字符串中的对应位转化为1。
3. 读取“再给一个数i” 查看bit[i] 是否为1，1则有存在，0则不存在。
从小到大排序
1，冒泡：
当前元素是a[i]，在a[0]到a[i-1]之间依次比对
若a[j]> a[i]，a[j]与a[i]进行交换，（小值向上浮动,保证每次循环后a[0]获得最小值，a[1]二小）
因要与左侧元素比对，故循环从a[1]开始直到数据尾a[n-1]
2,选择：
当前元素是a[i],在a[i+1]与a[n-1]之间依次比对，取出最小值与a[i]进行交换。
以保证：第一次：比较n个元素，取出最小的放在第一个位置（进行交换）
第二次：比较剩下的n-1个元素，取出第二小的放在第二个位置
...
因要与右侧元素比对，故循环从a[0]开始到a[n-2]结束
3，插入：
当前元素是a[i]，在a[0]到a[i-1]之间依次比对,
若a[j] > a[i]，a[j]右移到a[j+1]
否则，说明当前位置的前一个位置正是要插入的位置，跳出循环，将a[i]的值放到a[j+1]处即可
（保证每次的a[i]都放在恰当的位置）
因要与左侧元素比对，故循环从a[1]开始直到数据尾a[n-1]
注：
(1)若n较小，可采用直接插入或直接选择排序。
但当记录规模较大时，因为直接选择移动的记录数少于直接插人，所以宜用选直接选择排序。
冒泡： 比较次数，频繁的交换操作
直接插入：比较次数，频繁的移位操作
选择： 比较次数，更少的交换操作
4，归并排序：递归拆分与合并。将数组拆分成左右数组，进行合并。
5 ,快速排序：
1）性质: 若一组数已经排好序，那么对于此组数每一个元素来说，每一个元素的左边都比它小，右边都比它大。
应用此性质：将当前元素放到恰好位置，让左区的元素都比它小，右区的元素都比它大，然后递归，
直到区细分到单个元素为止。
过程：对于数组第一个元素进行排序，循环：将左区元素第一个比当前元素大的与右区第一个比当前元素小的进行交换，
直到左区的都比当前元素小，右区的都比当前元素大。然后递归左区与右区。
2）快速排序也是使用了分治法的思路，不需要合并，快速排序和归并排序都是分治法，它们的区别在于，快速排序不需
要合并，快速排序的平均运行时间为Θ(n log n)
6，希尔排序，将整个无序列分割成若干小的子序列分别进行插入排序的方法，
是插入排序的一种高效稳定的改进版本。
先取一个正整数d1
快速排序
算法的实现：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication31
{
class Program
{
public delegate void Sort(int[] arr);
static void Main(string[] args)
{
int[] arr = { 9,8,7,6,5,4,3,2,1};
//BubbleSorter(arr);
//Printf("BubbleSorter", arr);
//SelectSorter(arr);
//Printf("SelectSorter", arr);
InsertSorter(arr);
Printf("InsertSorter", arr);
//Printf("QuickSort", arr, QuickSort);
//QuickSort(arr,0,arr.Length-1);
//Printf("QuickSort",arr);
Console.Read();
}
public static void Printf(string type,int[] arr) {
Console.WriteLine(string.Format("-------------------{0}-------------------",type));
DateTime DateTime = DateTime.Now;
//System.Threading.Thread.Sleep(1000);
//sort(arr);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < arr.Length; i++) {
sb.Append(","+arr[i].ToString() );
}
Console.WriteLine(sb.ToString().Substring(1,sb.Length-1));
string timespent = (DateTime.Now.Subtract(DateTime)).TotalMilliseconds.ToString();
Console.WriteLine(string.Format("-------------------{0}：{1}s----------------", type, timespent));
}
//冒泡法，每次将元素放到合适的位置，
//保持当前元素之前的元素处在有序状态，然后将当前元素与之前的有序元素进行对比交换
//复杂度：1+2+..(n-1) = (n-1)*n/2,比上边的复杂度少了一半。
//冒泡：即相邻数据的交换
private static int[] BubbleSorter(int[] arr)
{
int key = 0;
int tmp = 0;
for (int i = 1; i < arr.Length; i++) {
key = arr[i];
for (int j = i - 1; j >= 0; j--) {
if (arr[j] > key) {
tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
return arr;
}
//选择排序：
//第一次：比较n个元素，取出最小的放在第一个位置（进行交换）
//第二次：比较剩下的n-1个元素，取出第二小的放在第二个位置
// ......
//(n-1)*n/2加少量交换，而冒泡是(n-1)*n/2加多次交换
private static void SelectSorter(int[] arr)
{
int key = 0;
int k = 0;
for (int i = 0; i < arr.Length-1; i++)
{
k = i;
for (int j = i + 1; j < arr.Length; j++)
{
if (arr[j] < arr[k] )
{
k = j;
}
}
key = arr[i];
arr[i] = arr[k];
arr[k] = key;
}
}
/*
插入法，每次将元素放到最合适的位置，
保持当前元素之前的元素处在有序状态，然后将当前元素与之前的有序元素进行对比
若对比的元素大于当前元素，则将此对比的元素右移一位，若对比元素小于当前元素，说明此对比元素位置之后的那个
位置正是要插入的位置，插入即可
注：1,与增强版冒泡排序相同的一点是保持当前元素之前的元素处于有序状态，
然后逐个比较，满足条件的元素进行右移操作而不是交换。
2,参考打牌，拾起一张牌，放已排好顺序的牌堆中进行插入，右移每张牌直到找到比它小的，然后插入到之前即可。
//(n-1)*n/2加少量移位，比选择好一些
*/
private static void InsertSorter(int[] arr)
{
int key = 0;
int j = 0;
for (int i = 1; i < arr.Length; i++)
{
key = arr[i];
for (j=i-1; j >= 0; j--)
{
if (arr[j] > key)
{
arr[j + 1] = arr[j];
}
else { break; }
}
arr[j+1] = key;
}
}
///快速排序：利用的性质，若一个数组排好顺序，那么对于每一个元素来说，它左边的都比此元素小，右边的都比此元素大。
///过程，对于数组第一个元素进行排序，循环：将左区元素第一个比当前元素大的与右区第一个比当前元素小的进行交换，
///直到左区的都比当前元素小，右区的都比当前元素大。然后递归左区与右区。
///（若左区或右区进入对方区域，则说明循环完毕，跳出即可。）
///保证得到的结果是：它左边的元素都比此元素小，右边的元素都比此元素大
///然后分别从此元素左侧、若侧元素进行快速排序
private static void QuickSort(int[] arr, int left,int right) {
if (left >= right) { return; }
int i=left;
int j=right+1;
while (true)
{
while (i < arr.Length-1 && arr[++i] < arr[left]) ;
while (j >= 0 && arr[--j] > arr[left]) ;
if (i >= j) { break; }
else {
swap(ref arr[i], ref arr[j]);
}
}
swap(ref arr[left], ref arr[j]);
QuickSort(arr, left, j - 1);
QuickSort(arr, j + 1, right);
}
//交换两个数
static void swap( ref int left,ref int right) {
int tmp = left;
left = right;
right = tmp;
}
///
/// 归并排序：递归拆分与合并。将数组拆分成左右数组，进行合并。
int[] MeargeSort(int[] data)
{
//取数组中间下标
int middle = data.Length / 2;
//初始化临时数组let,right，并定义result作为最终有序数组
int[] left = new int[middle], right = new int[middle], result = new int[data.Length];
if (data.Length % 2 != 0)//若数组元素奇数个，重新初始化右临时数组
{
right = new int[middle + 1];
}
if (data.Length <= 1)//只剩下1 or 0个元数，返回，不排序
{
return data;
}
int i = 0, j = 0;
foreach (int x in data)//开始排序
{
if (i < middle)//填充左数组
{
left[i] = x;
i++;
}
else//填充右数组
{
right[j] = x;
j++;
}
}
left = MeargeSort(left);//递归左数组
right = MeargeSort(right);//递归右数组
result = Merge(left, right);//开始排序
//this.Write(result);//输出排序
return result;
}
///
/// 归并排序之并:排序在这一步
///
/// 左数组
/// 右数组
/// 合并左右数组排序后返回
int[] Merge(int[] a, int[] b)
{
//定义结果数组，用来存储最终结果
int[] result = new int[a.Length + b.Length];
int i = 0, j = 0, k = 0;
while (i < a.Length && j < b.Length)
{
if (a[i] < b[j])//左数组中元素小于右数组中元素
{
result[k++] = a[i++];//将小的那个放到结果数组
}
else//左数组中元素大于右数组中元素
{
result[k++] = b[j++];//将小的那个放到结果数组
}
}
while (i < a.Length)//这里其实是还有左元素，但没有右元素
{
result[k++] = a[i++];
}
while (j < b.Length)//右右元素，无左元素
{
result[k++] = b[j++];
}
return result;//返回结果数组
}
}
}
克拉默法则
应用：
设有未知数x1、x2、x3、x4，满足以下条件：
x1 + 3*x2 -2*x3 + x4 = 1
2*x1 + 5*x2 -3*x3 + 2*x4 = 3
-3*x1+ 4*x2 + 8*x3 -2*x4 = 4
6*x1 -x2 - 6*x3 + 4*x4 =2
用克拉默法则求出x1、x2、x3、x4的值。
解题方法：
我们在(A1:E4)单元格分别输入系数和等号右边的数值
1 3 -2 1 1
2 5 -3 2 3
-3 4 8 -2 4
6 -1 -6 4 2
在单元格A5输入公式：
=MDETERM(A1:D4) 注意这里是（A1:D4）,而不是（A1:E4）
MDETERM
返回一个数组的矩阵行列式的值。
语法
MDETERM(array)
Array 行数和列数相等的数值数组
MDETERM(A1:C3) 等于
A1*(B2*C3-B3*C2) + A2*(B3*C1-B1*C3) + A3*(B1*C2-B2*C1)
选中(E1:E4)这一列单元格，复制：按Ctrl + c，
然后点中A1单元，粘贴：按Ctrl + v，
A5单元格变成了 -34 ，于是得 D1 = -34
取消：按Ctrl + z，A5单元格仍变回17。点中B1单元格，粘贴：按Ctrl + v，
A5单元格变成了 0 ，于是得 D2 = 0
取消：按Ctrl + z，A5单元格仍变回17。点中C1单元格，粘贴：按Ctrl + v，
A5单元格变成了 17，于是得 D3 = 17
取消：按Ctrl + z，A5单元格仍变回17。点中D1单元格，粘贴：按Ctrl + v，
A5单元格变成了 85，于是得 D4 = 85
根据克拉默法则：
x1 = D1 / D = -34 / 17 = -2
x2 = D2 / D = 0 / 17 = 0
x3 = D3 / D = 17 / 17 = 1
事件的完成中间要经过许多状态，如提交订单,订单审核通过,从北京移仓,抵达广州开始配货,广州发货,收货并确认等，客户在查询时须提供订单的状态，显示时若能以流程图的方式显式出来，告诉客户目前到哪个状态，还有几个状态则效果会很好。 如下：
系统：主要用于数据的输入输出。在输出方面做深入的分析，显示，如报表。主要用于内部服务，访问量相对小一些。
网站：主要用于数据的简单显示。，主要用于对外服务，访问量相对大。
系统的作用：深入分析数据，减少人力成本，提高信息传播、共享速度。
1, 网站内容要吸引人，以留住回头客。见http://coolshell.cn/, 内容新颖，更新频繁。
2，在知名论坛发贴，在帖子中引一下自己的网站
3，在知名论坛认真回复，在回复中引入自己的网站。见回复：http://blog.csdn.net/yifengling0/archive/2010/10/18/5949694.aspx
1，随机产生，插入数据库之前判断数据库内是否存在，当数据量大时判断是否重复速度就比较慢。最好能产生时就保证唯一性。
2，随机产生 再加上主键，因为主键唯一，就保证了数据的唯一性。不过要先insert得到主键再update随机码。
常见的三层架构基本分为如下部分：
* 数据访问层DAL:用于实现与数据库的交互和访问，从数据库获取数据或数据库的部分。
* 业务逻辑层BLL:对上下交互的数据进行逻辑处理。
* 表示层WEB:主要是实现与用户的交互。
* 注：日常开发中，为了复用一些共同的东西，会把这些通过的东西抽象出来，以便在多个层中传递，如实体层Model，工具层Common
1，开放 – 封闭法则（OCP）
* 对扩展是开放的，对更新是封闭的。
* 可以添加新的代码来扩展系统的行为，但不能对已有代码进行修改。
2，Liskov替换法则（LSP）:子类应当可以替换父类并出现在父类能够出现的任何地方。
3，单一职责原则（SRP）:就一个类而言，应该仅有一个引起它变化的原因，即：每个类集中做好一件事，类的职责简单而集中。，在需求变化时，只修改一个地方。
4，依赖倒置原则（DIP）:
* 高层模块不应依赖于底层模块，两者都应依赖于抽象。
* 抽象不应依赖于细节，细节应依赖于抽象。
* 针对接口编程，不针对实现编程。
1. 用最简单的方法判断一个LONG整形的数A是2^n（2的n次方）
* 若一个数是2^n,那么此数的二进制形式应为： 100000…,在所有的数位中，只有一个是1，其它都为0
* 当用此数减1时，就会变成： 01111111….,在所有数位为1，对应数位为0，那么二者相与，就会为0
* 故：当此数与比他小一的数相与若为0，则此数是2的n次方，算法为：判断 i&(i-1) 是否为0，若为0，则此数是2的n次方
2. 扩展：判断一个LONG整形的数是否是2^n – 1
* 设：x为一个2^n -1数， 那么x+1= 2^n = (x+1)&x
* 即：用x&(x+1)若为0，则是2^n – 1数
3.? (A|B|C) & A = A
令：X = A|B|C, 因为进行的是或运算， 那么在A中位数为1的数位上，对应的X数位也为1，这些为1的数位与A进行与操作，结果为1.?????? 在X的其它数位上，因A在这些数位上为0，故X的其它数位与A相与为0，总和二者知：结果为A
扩展：权限设计，每个权限给予一个数字，每个人的权限值即为这些权限的或操作结果，那么判断此人是否拥有A权限，即用此人总的权限值与A进行与操作即可，若结果为A,则说明拥有此权限。
1，过程化：新增一种需求，相应增加一种方法，对应调用。
* 对过Switch,据传入的参数调用对应的方法，这些方法可能执行相同的流程，但不可固定下来。
2，对象化：新增一种需求，相应增加一种对象，通过多态来完成调用。核心的代码调控模块可以固定下来。
* 对过Switch,据传入的参数产生相应的对象，接着利用多态将流程固定下来。
3，XML配置化：新增一种需求，相应增加一条配置信息及对应的处理对象，核心代码读取需求并调用。(Spring)
* 无须Switch,配置文件中设置需求与类的关系，将需求读入列表中，将一种需求提出时，直接在配置文件中找到对应的类，调用之。
* 并且对象的更新与需要的对应在配置文件中完成，弹性非常好。
* 如：
//读取类信息填充成下拉表，据选择的值建立相应的类对象
* string mediatype = cbbMediaType.SelectedItem.ToString();
//得到类名
* string factoryDllName = ConfigurationSettings.AppSettings[mediaType].ToString();
//构造类对象
* ImediaFactory factory = (ImediaFactory)Activator.CreateInstance(“MediaLibrary”,factoryDllName).Unwrap();
* Imedia media = factory.CreateMedia();
* media.Play();
实现参见Gmail: 面向配置的程序设计
?在正式环境的web.config中assemblies结点下加入：???
<add assembly=”System.Management, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B03F5F7F11D50A3A”/> 即可。
即：引用的系统命名空间在web.config的assemblies结点下存储。