常见的几种编码


Unicode编码

Unicode 是基于国际标准化组织(International Organization for Standardization,简称ISO)所制定的 ISO/IEC 10646 ,即通用字符集(Universal Character Set,简称 UCS)的标准来发展,在1991年首次以书本的形式(The Unicode Standard)对外发布。 Unicode 的编码方式与 ISO 10646 的通用字符集(UCS)概念相对应,使用16位编码空间。16位Unicode字符构成基本多文种平面(Basic Multilingual Plane,简称BMP),最多可以表示65536个字符。基本满足各种语言的使用。最新的 Unicode 版本定义了16个辅助平面,两者合起来达到32位编码空间,可以涵盖一切语言所用的符号。目前辅助平面的工作主要集中在第二和第三平面的中日韩统一表意文字中。

GB2312 编码

GB 2312-80 编码是中华人民共和国国家标准汉字信息交换用编码,全称《信息交换用汉字编码字符集基本集》标准号为GB 2312-80(GB是“国标”二字的汉语拼音缩写),由中华人民共和国国家标准总局发布,1981年5与1号发布,1981年10月1日实施。它是一个简化字汉字的编码,通行于中国大陆地区及海外使用简体中文的地区(如新加坡等)。 GB 2312-80 收录简化汉字及一般符号、序号、数字、拉丁字母、日文假名、希腊字母、俄文字母、汉语拼音符号、汉语注音字母、共7445个图形字符。其中汉字以外的图形字符682个,汉字6763个。 GB 2312-80 把收录的汉字分成两级。第一级汉字是常用汉字,计3755个,置于1655区,按汉语拼音字母/笔形顺序排列;第二级汉字是次常用汉字,计3008个,置于5687区,按部首/笔画顺序排列。字音以普通话审音委员会发表的《普通话异读词三次审音总表初稿》(1963年出版)为准,字形以中华人民共和国文化部、中国文字改革委员会公布的《印刷通用汉字字形标》(1964年出版)为准。

GBK编码

GBK 编码标准,全称《汉字内码扩展规范》(GBK),英文名称 Chinese Internal Code Specification,中华人民共和国全国信息技术标准化技术委员会1995年12月1日制定,国家技术监督局标准化司、电子工业部科技与质量监督司1995年12月15日联合以技监标函[1995]229号文件的形式,将它确定为技术规范指导性文件,发布和实施。这一版的GBK规范为1.0版。GB即“国标”,K是“扩展”的汉语拼音第一个字母。 GBK向下与GB 2312编码兼容,向上支持 ISO 10646.1 国际标准,是前者向后者过度过程中的一个承上启下的标准。 GBK共收录21886个汉字和图形符号,其中汉字(包括部首和构件)21003个,图形符号883个。

GB 18030编码

GB 18030有两个版本:GB 18030-2000和GB 18030-2005. GB 18030-2000是GBK的取代版本,它的主要特点是在GBK的基础上增加了CJK统一汉字扩充A的汉字,GB 18030-2005的主要特点是在GB 18030-2000基础上增加了CJK统一汉字扩充B的汉字。 GB 18030-2000,全称《信息技术 信息交换用汉字编码字符集 基本集的扩充》,中华人民共和国信息产业部电子工业标准化研究所起草,由国家质量技术监督局于2000年3月17号发布。GB 18030-2000共收录27533个汉字。 GB 18030,全称:国家标准 GB 18030-2005《信息技术 中文编码字符集》,是中华人民共和国现在最新的内码字符集,是GB 18030-2000的修订版。GB18030-2005 共收录汉字70244个。现行版本为国家质量监督检验总局和中国国家标准化管理委员会于2005年11月8日发布,2006年5月1日实施。此规格为在中国境内所有软件产品支持的强制规格。

BIG 5字符集

BIG-5 码是通行于台湾、香港地区的一个繁体字编码方案,俗称“大五码”。 BIG-5 码收录13468个符号和汉字,符号408个,汉字13060个,分为常用字和次常用字两部分,各部分中的汉字按照笔画/部首排列。其中:常用字5401个,次常用字7659。

GB/T 12345编码

GB/T 12345-90 编码全称《信息交换用汉字编码字符集 辅助集》,标准号为GB/T 12345-90,1990年6月13日发布,1990年12月1日实施,是一个关于繁体字的编码标准。所谓“辅助集”,是与“基本集”(GB2312-80)相对应而言。即:GB/T 12345 是与GB2312相对应的图形字符集。原则上,本字符集是将GB2312中的简化字用相应的繁体字替换而成。因此,这些替代的繁体字具有与被替代的简化字相同的编码;未曾简化的汉字以及非汉字图形字符,仍是GB2312中的汉字和图形字符,并具有与之相同的编码。 GB/T 12345-90 共收录7583 个图形字符。汉字以外的图形字符716个,汉字6866个,其中一级汉字3755个,二级汉字3008个,增补汉字103个。 关于繁体字替换简化字的原则,GB/T 12345 注明:“本标准原则上按照《简化字总表》中所列繁体字与简化字的对应关系进行替换。”《简化字总表》由中国文字改革委员会1964年5月发表,后经国家语言文字工作委员会作个别修改,国务院1986年6月4号批准发表。

748编码

748编码仅用于方正软件和系统

算法中的大O表示法


1.算法概念

计算机科学中的算法指的就是计算机执行的指令。

算法是计算机处理信息的本质,因为计算机程序本质上是一个算法来告诉计算机确切的步骤来执行一个指定的任务,如计算职工的薪水或打印学生的成绩单。

一般地,当算法在处理信息时,会从输入设备或数据的存储地址读取数据,把结果写入输出设备或某个存储地址供以后再调用。

1
         -----------       
2
输入 --> |   算法    | --> 输出
3
         -----------

算法的核心是创建问题抽象的模型和明确求解目标,之后可以根据具体的问题选择不同的模式和方法完成算法的设计。

2. 时间复杂度

算法的时间复杂度是指算法需要消耗的时间资源。

一般来说,计算机算法是问题规模n 的函数f(n),算法的时间复杂度也因此记做:

1
T(n) = O(f(n))

算法执行时间的增长率与f(n) 的增长率正相关,称作渐近时间复杂度(Asymptotic Time Complexity),简称时间复杂度。

3. 空间复杂度

算法的空间复杂度是指算法需要消耗的空间资源。

其计算和表示方法与时间复杂度类似,一般都用复杂度的渐近性来表示。

同时间复杂度相比,空间复杂度的分析要简单得多。

4. 大 O 表示法

  • 什么是大 O 表示法?
    我们常常会听到有人说,“这个算法在最糟情况下的运行时间是 O(n^2) 而且占用了 O(n) 大小的空间”,他的意思是这个算法有点慢,不过没占多大空间。
    这里的 O(n^2)O(n) 就是我们通常用来描述算法复杂度的大 O 表示法。
    大 O 表示法能让你对一个算法的运行时间占用空间有个大概概念。

  • 大 O 表示法怎么看?怎么用?
    假设一个算法的时间复杂度是 O(n),n 在这里代表的意思就是数据的个数。举个例子,如果你的代码用一个循环遍历 100 个元素,那么这个算法就是 O(n),n 为 100,所以这里的算法在执行时就要做 100 次工作。

  • 大O符号是关于一个算法的最坏情况的。比如说,你要从一个大小为 100 的数组(数组中存的都是数字)中找出一个数值等于 10 的元素,我们可以从头到尾扫描一遍,这个复杂度就是 O(n),这里 n 等于 100,实际上呢,有可能第 1 次就找到了,也有可能是第 100 次才找到,但是大 O 表示法考虑的是最坏的情况,也就是一个算法理论上要执行多久才能覆盖所有的情况。

  • 常见的时间复杂度有:
    常数阶O(1),对数阶O(log2n),线性阶O(n),线性对数阶O(nlog2n),平方阶O(n2),立方阶O(n3),…, k次方阶O(nk),指数阶O(2n)。随着问题规模n的不断增大,上述时间复杂度不断增大,算法的执行效率越低。

  • 说明:

    • 大部分情况下你用直觉就可以知道一个算法的大 O 表示法
    • 大 O 表示法只是一种估算,当数据量大的时候才有用
    • 这种东西仅仅在比较两种算法哪种更好的时候才有点用。但归根结底,你还是要实际测试之后才能得出结论。而且如果数据量相对较小,哪怕算法比较慢,在实际使用也不会造成太大的问题。

要知道一个算法的大 O 表示法通常要通过数学分析。在这里我们不会涉及具体的数学,不过知道不同的值意味着什么会很有用。所以这里有一张方便的表。n 在这里代表的意思是数据的个数。举个例子,当对一个有 100 个元素的数组进行排序时,n = 100

Big-O 名字 描述
O(1) 常数级 最好的。不论输入数据量有多大,这个算法的运行时间总是一样的。例子: 基于索引取出数组中对应的元素。
O(log n) 对数级 相当好。这种算法每次循环时会把需要处理的数据量减半。如果你有 100 个元素,则只需要七步就可以找到答案。1000 个元素只要十步。100,0000 元素只要二十步。即便数据量很大这种算法也非常快。例子:二分查找。
O(n) 线性级 还不错。如果你有 100 个元素,这种算法就要做 100 次工作。数据量翻倍那么运行时间也翻倍。例子:线性查找。
O(n log n) 线性对数级 还可以。比线性级差了一些,不过也没那么差劲。例子:最快的通用排序算法。
O(n^2) 二次方级 有点慢。如果你有 100 个元素,这种算法需要做 100^2 = 10000 次工作。数据量 x 2 会导致运行时间 x 4 (因为 2 的 2 次方等于 4)。例子:循环套循环的算法,比如插入排序。
O(n^3) 三次方级 特别慢。如果你有 100 个元素,那么这种算法就要做 100^3 = 100,0000 次工作。数据量 x 2 会导致运行时间 x 8。例子:矩阵乘法。
O(2^n) 指数级 超级慢。这种算法你要想方设法避免,但有时候你就是没得选。加一点点数据就会把运行时间成倍的加长。例子:旅行商问题。
O(n!) 阶乘级 比蜗牛还慢!不管干什么都要跑个 N 年才能得到结果。

大部分情况下你用直觉就可以知道一个算法的大 O 表示法。比如说,如果你的代码用一个循环遍历你输入的每个元素,那么这个算法就是 O(n)。如果是循环套循环,那就是 O(n^2)。如果 3 个循环套在一起就是 O(n^3),以此类推。

注意,大 O 表示法只是一种估算,当数据量大的时候才有用。举个例子,[插入排序](Insertion Sort/)的最糟情况运行时间是 O(n^2)。 理论上来说它的运行时间比[归并排序](Merge Sort/)要慢一些。归并排序是 O(n log n)。但对于小数据量,插入排序实际上更快一些,特别是那些已经有一部分数据是排序好的数组。

算法-冒泡排序


算法-冒泡排序

简单定义:大数下沉,小数起泡
代码实现如下:

1
void funcScort(int arr[],int len){  
2
    for (int i = 0; i< len - 1; i++) {  
3
        for(int j = 0 ;j<len -1-i;j++ ){  
4
            if (arr[j]>arr[j+1]) {  
5
                int temp;  
6
                temp = arr[j];  
7
                arr[j] = arr[j+1];  
8
                arr[j+1] = temp;  
9
            }  
10
        }  
11
    }  
12
}  
13
14
int main(int argc, const char * argv[]) {  
15
    int a[10] = {1,23,5,89,53,33,98,75,64,48};  
16
    //排序  
17
    funcScort(a, 10);  
18
    //打印  
19
    for (int i = 0; i<10; i++) {  
20
        printf("%d\t",a[i]);  
21
    }  
22
    return 0;  
23
}  
24
25
//输出结果:1 5 23 33 48 53 64 75 89 98

算法-选择排序

简单定义:每次把未查找部分的最小的数放在前面
代码实现如下:

1
void selectSort(int arr[],int len){  
2
    for (int i=0; i<len-1; i++) {  
3
        for (int j = i+1; j<len; j++) {  
4
            if (arr[i]>arr[j]) {  
5
                int temp;  
6
                temp = arr[i];  
7
                arr[i] = arr[j];  
8
                arr[j] = temp;  
9
            }  
10
        }  
11
    }  
12
}  
13
14
int main(int argc, const char * argv[]) {  
15
    // insert code here...  
16
    int a[10] = {1,23,5,89,53,33,98,75,64,48};  
17
    //排序  
18
    selectSort(a, 10);  
19
    //打印  
20
    for (int i = 0; i<10; i++) {  
21
        printf("%d\t",a[i]);  
22
    }  
23
    return 0;  
24
}
25
26
//输出结果:1 5 23 33 48 53 64 75 89 98
Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×