精华内容
下载资源
问答
  • Huffman编码解码

    万次阅读 多人点赞 2016-06-05 14:06:49
    Huffman编码解码霍夫曼(Huffman)编码问题也就是最优编码问题,通过比较权值逐步构建一颗Huffman树,再由Huffman树进行编码、解码。其步骤是先构建一个包含所有节点的线性表,每次选取最小权值的两个节点,生成一个...

    Huffman编码解码

    霍夫曼(Huffman)编码问题也就是最优编码问题,通过比较权值逐步构建一颗Huffman树,再由Huffman树进行编码、解码。

    其步骤是先构建一个包含所有节点的线性表,每次选取最小权值的两个节点,生成一个父亲节点,该父亲节点的权值等于两节点权值之和,然后将该父亲节点加入到该线性表中,再重复上述步骤,直至构成一个二叉树,注意已经使用过的节点不参与。

    Huffman编码贪心原理

    编码原理

    把每个字符看作一个单节点子树放在一个树集合中,每棵子树的权值等于相应字符的频率。每次取权值最小的两棵子树合成一棵新树,并重新放到集合中。新树的权值等于两棵子树权值之和。

    贪心选择性

    xy是频率最小的两个字符,则存在前缀码使得xy具有相同码长,且仅有最后一位编码不同。换句话说,贪心选择保留了最优解。

    优化子结构

    T是加权字符集C的最优编码树,xy是树T中两个叶子,且互为兄弟结点,z是它们的父结点。若把z看成具有频率f(z)=f(x)+f(y)的字符,则树T=T{x,y}是字符集C=C{x,y}{z}的一棵最优编码树。换句话说,原问题的最优解包含子问题的最优解。

    举例说明

    编码表

    字符 a b c d e f
    频率 45 13 12 16 9 5
    编码 0 101 100 111 1101 1100

    Huffman编码

    下面将解释为什么是这样编码,在解释之前先说明一个概念:

    • 前缀码:任何一个编码都不是另一个编码的前缀(prefix)。

    如果Huffman编码符合前缀码的要求的话,那么绝不会出现编码二义性的问题。而且通过权值这一参考量,构成了最优编码。

    原理图

    原始节点


    构建Huffman树的步骤


    Huffman编码

    Huffman编码解码算法实现

    节点信息结构

    // 节点信息结构
    struct Node {
        // 值
        string value;
        // 权值
        float weight;
        // 父节点
        int parent;
        // 左子节点
        int lchild;
        // 右子节点
        int rchild;
    };

    编码信息结构

    // 编码信息结构
    struct Code {
        // 编码字符
        int bit[maxBit];
        // 开始位置
        int start;
        // 值
        string value;
    };

    全局常量和全局变量

    const int INF = 1000000000;
    const int maxBit = 1 << 5;
    const int maxNode = 1 << 10;
    const int maxCode = 1 << 10;
    
    // 节点数组
    Node huffman[maxNode];
    // 编码数组
    Code huffmanCode[maxCode];
    // n个字符串
    int n;

    初始化Huffman树

    // 初始化Huffman树
    void initHuffmanTree() {
        for(int i = 0; i < (2 * n) - 1; i++) {
            huffman[i].weight = 0;
            huffman[i].value = "";
            huffman[i].parent = -1;
            huffman[i].lchild = -1;
            huffman[i].rchild = -1;
        }
    }

    构造Huffman树

    // 贪心法
    // 构造Huffman树
    void huffmanTree() {
        // 循环构建Huffman树
        for(int i = 0; i < n - 1; i++) {
            // m1,m2存放所有节点中权值最小的两个节点权值
            int m1 = INF;
            int m2 = INF;
            // x1,x2存放所有节点中权值最小的两个节点下标
            int x1 = 0;
            int x2 = 0;
            for(int j = 0; j < n + i; j++) {
                if(huffman[j].weight < m1 && huffman[j].parent == -1) {
                    m2 = m1;
                    x2 = x1;
                    m1 = huffman[j].weight;
                    x1 = j;
                } else if(huffman[j].weight < m2 && huffman[j].parent == -1) {
                    m2 = huffman[j].weight;
                    x2 = j;
                }
            }
            // 设置找到的两个节点的x1,x2的父节点信息
            huffman[x1].parent = n + i;
            huffman[x2].parent = n + i;
            huffman[n + i].weight = huffman[x1].weight + huffman[x2].weight;
            huffman[n + i].lchild = x1;
            huffman[n + i].rchild = x2;
        }
    }

    Huffman编码

    // huffman编码
    void huffmanEncoding() {
        // 临时结构
        Code cd;
        int child, parent;
        for(int i = 0; i < n; i++) {
            cd.value = huffman[i].value;
            cd.start = n - 1;
            child = i;
            parent = huffman[child].parent;
            // 未到根节点
            while(parent != -1) {
                // 左孩子
                if(huffman[parent].lchild == child) {
                    cd.bit[cd.start] = 0;
                } else {
                    // 右孩子
                    cd.bit[cd.start] = 1;
                }
                cd.start--;
                // 设置下一循环条件
                child = parent;
                parent = huffman[child].parent;
            }
    
            // 保存求出的每个叶子节点的Huffman编码结构
            for(int j = cd.start + 1; j < n; j++) {
                huffmanCode[i].bit[j] = cd.bit[j];
            }
            huffmanCode[i].start = cd.start;
            huffmanCode[i].value = cd.value;
        }
    }

    打印Huffman编码信息

    // 打印每个叶节点的Huffman编码和编码起始值
    void printHuffmanCode() {
        for(int i = 0; i < n; i++) {
            cout << "第" << i + 1 << "个字符 " << huffmanCode[i].value << " 的Huffman编码为:";
            for(int j = huffmanCode[i].start + 1; j < n; j++) {
                cout << huffmanCode[i].bit[j];
            }
            cout << " 编码起始值为:" << huffmanCode[i].start << endl;
        }
        cout << endl;
    }

    解码Huffman编码

    // 解码Huffman编码
    void HuffmanDecoding(string s) {
        vector<string> v;
        // 标识位
        int ok = 1;
        for(int i = 0; i < s.length();) {
            // 根节点
            int x = (2 * n) - 1 - 1;
            // 不为叶子节点
            while(huffman[x].lchild != -1 && huffman[x].rchild != -1) {
                // 左子树
                if(s[i] == '0') {
                    x = huffman[x].lchild;
                } else {
                    // 右子树
                    x = huffman[x].rchild;
                }
                i++;
                // 处理0,1序列有误
                // 这种情况一般是结尾0,1序列少了,导致最后一个字符串解码失败
                if(i == s.length() && huffman[x].lchild != -1) {
                    ok = 0;
                    break;
                }
            }
    
            if(ok) {
                v.push_back(huffman[x].value);
            }
        }
        if(ok) {
            for(int i = 0; i < v.size(); i++) {
                cout << v[i];
            }
            cout << endl << endl;
        } else {
            cout << "解码有误。" << endl << endl;
        }
    }

    主函数

    int main() {
        while(true) {
            // 初始化
    
            // 输入数据
            cout << "请输入字符串个数(0退出):";
            cin >> n;
            if(!n) {
                break;
            }
    
            // 初始化Huffman树
            initHuffmanTree();
    
            for(int i = 0; i < n; i++) {
                cout << "一共" << n << "个字符串,请输入第" << i + 1 << "个字符串及其权值:";
                cin >> huffman[i].value;
                cin >> huffman[i].weight;
            }
    
            // 构造Huffman树
            huffmanTree();
    
            // huffman编码
            huffmanEncoding();
    
            // 打印每个叶节点的Huffman编码和编码起始值
            printHuffmanCode();
    
            while(true) {
                cout << "请输入一段符合上述编码的0,1序列(q进入下一次编码解码):";
                string s;
                cin >> s;
                if(s[0] == 'q') {
                    cout << endl;
                    break;
                }
                cout << "原始0,1序列为:" << s << endl;
                cout << "解码后为:";
                // 解码
                HuffmanDecoding(s);
            }
        }
        return 0;
    }

    测试主程序

    #include <iostream>
    #include <vector>
    #include <string>
    
    using namespace std;
    
    const int INF = 1000000000;
    const int maxBit = 1 << 5;
    const int maxNode = 1 << 10;
    const int maxCode = 1 << 10;
    
    // 节点信息结构
    struct Node {
        // 值
        string value;
        // 权值
        float weight;
        // 父节点
        int parent;
        // 左子节点
        int lchild;
        // 右子节点
        int rchild;
    };
    
    // 编码信息结构
    struct Code {
        // 编码字符
        int bit[maxBit];
        // 开始位置
        int start;
        // 值
        string value;
    };
    
    // 节点数组
    Node huffman[maxNode];
    // 编码数组
    Code huffmanCode[maxCode];
    
    // n个字符串
    int n;
    
    // 初始化Huffman树
    void initHuffmanTree() {
        for(int i = 0; i < (2 * n) - 1; i++) {
            huffman[i].weight = 0;
            huffman[i].value = "";
            huffman[i].parent = -1;
            huffman[i].lchild = -1;
            huffman[i].rchild = -1;
        }
    }
    
    
    // 贪心法
    // 构造Huffman树
    void huffmanTree() {
        // 循环构建Huffman树
        for(int i = 0; i < n - 1; i++) {
            // m1,m2存放所有节点中权值最小的两个节点权值
            int m1 = INF;
            int m2 = INF;
            // x1,x2存放所有节点中权值最小的两个节点下标
            int x1 = 0;
            int x2 = 0;
            for(int j = 0; j < n + i; j++) {
                if(huffman[j].weight < m1 && huffman[j].parent == -1) {
                    m2 = m1;
                    x2 = x1;
                    m1 = huffman[j].weight;
                    x1 = j;
                } else if(huffman[j].weight < m2 && huffman[j].parent == -1) {
                    m2 = huffman[j].weight;
                    x2 = j;
                }
            }
            // 设置找到的两个节点的x1,x2的父节点信息
            huffman[x1].parent = n + i;
            huffman[x2].parent = n + i;
            huffman[n + i].weight = huffman[x1].weight + huffman[x2].weight;
            huffman[n + i].lchild = x1;
            huffman[n + i].rchild = x2;
        }
    }
    
    // huffman编码
    void huffmanEncoding() {
        // 临时结构
        Code cd;
        int child, parent;
        for(int i = 0; i < n; i++) {
            cd.value = huffman[i].value;
            cd.start = n - 1;
            child = i;
            parent = huffman[child].parent;
            // 未到根节点
            while(parent != -1) {
                // 左孩子
                if(huffman[parent].lchild == child) {
                    cd.bit[cd.start] = 0;
                } else {
                    // 右孩子
                    cd.bit[cd.start] = 1;
                }
                cd.start--;
                // 设置下一循环条件
                child = parent;
                parent = huffman[child].parent;
            }
    
            // 保存求出的每个叶子节点的Huffman编码结构
            for(int j = cd.start + 1; j < n; j++) {
                huffmanCode[i].bit[j] = cd.bit[j];
            }
            huffmanCode[i].start = cd.start;
            huffmanCode[i].value = cd.value;
        }
    }
    
    // 打印每个叶节点的Huffman编码和编码起始值
    void printHuffmanCode() {
        for(int i = 0; i < n; i++) {
            cout << "第" << i + 1 << "个字符 " << huffmanCode[i].value << " 的Huffman编码为:";
            for(int j = huffmanCode[i].start + 1; j < n; j++) {
                cout << huffmanCode[i].bit[j];
            }
            cout << " 编码起始值为:" << huffmanCode[i].start << endl;
        }
        cout << endl;
    }
    
    // 解码Huffman编码
    void HuffmanDecoding(string s) {
        vector<string> v;
        // 标识位
        int ok = 1;
        for(int i = 0; i < s.length();) {
            // 根节点
            int x = (2 * n) - 1 - 1;
            // 不为叶子节点
            while(huffman[x].lchild != -1 && huffman[x].rchild != -1) {
                // 左子树
                if(s[i] == '0') {
                    x = huffman[x].lchild;
                } else {
                    // 右子树
                    x = huffman[x].rchild;
                }
                i++;
                // 处理0,1序列有误
                // 这种情况一般是结尾0,1序列少了,导致最后一个字符串解码失败
                if(i == s.length() && huffman[x].lchild != -1) {
                    ok = 0;
                    break;
                }
            }
    
            if(ok) {
                v.push_back(huffman[x].value);
            }
        }
        if(ok) {
            for(int i = 0; i < v.size(); i++) {
                cout << v[i];
            }
            cout << endl << endl;
        } else {
            cout << "解码有误。" << endl << endl;
        }
    }
    
    int main() {
        while(true) {
            // 初始化
    
            // 输入数据
            cout << "请输入字符串个数(0退出):";
            cin >> n;
            if(!n) {
                break;
            }
    
            // 初始化Huffman树
            initHuffmanTree();
    
            for(int i = 0; i < n; i++) {
                cout << "一共" << n << "个字符串,请输入第" << i + 1 << "个字符串及其权值:";
                cin >> huffman[i].value;
                cin >> huffman[i].weight;
            }
    
            // 构造Huffman树
            huffmanTree();
    
            // huffman编码
            huffmanEncoding();
    
            // 打印每个叶节点的Huffman编码和编码起始值
            printHuffmanCode();
    
            while(true) {
                cout << "请输入一段符合上述编码的0,1序列(q进入下一次编码解码):";
                string s;
                cin >> s;
                if(s[0] == 'q') {
                    cout << endl;
                    break;
                }
                cout << "原始0,1序列为:" << s << endl;
                cout << "解码后为:";
                // 解码
                HuffmanDecoding(s);
            }
        }
        return 0;
    }

    输出数据

    请输入字符串个数(0退出):6
    一共6个字符串,请输入第1个字符串及其权值:a 45
    一共6个字符串,请输入第2个字符串及其权值:b 13
    一共6个字符串,请输入第3个字符串及其权值:c 12
    一共6个字符串,请输入第4个字符串及其权值:d 16
    一共6个字符串,请输入第5个字符串及其权值:e 9
    一共6个字符串,请输入第6个字符串及其权值:f 51个字符 a 的Huffman编码为:0 编码起始值为:42个字符 b 的Huffman编码为:101 编码起始值为:23个字符 c 的Huffman编码为:100 编码起始值为:24个字符 d 的Huffman编码为:111 编码起始值为:25个字符 e 的Huffman编码为:1101 编码起始值为:16个字符 f 的Huffman编码为:1100 编码起始值为:1
    
    请输入一段符合上述编码的0,1序列(q进入下一次编码解码):010011110111011100
    原始0,1序列为:010011110111011100
    解码后为:acdbef
    
    请输入一段符合上述编码的0,1序列(q进入下一次编码解码):00010010110010111011101110011001111110101
    原始0,1序列为:00010010110010111011101110011001111110101
    解码后为:aaacbcbeeffddab
    
    请输入一段符合上述编码的0,1序列(q进入下一次编码解码):010110011
    原始0,1序列为:010110011
    解码后为:解码有误。
    
    请输入一段符合上述编码的0,1序列(q进入下一次编码解码):q
    
    请输入字符串个数(0退出):0
    
    Process returned 0 (0x0)   execution time : 16.174 s
    Press any key to continue.
    展开全文
  • Golang Base64编码解码

    千次阅读 2020-06-17 17:58:45
    Golang Base64编码解码 Golang内置支持Base64编码解码,Go的encoding/base64包遵照RFC 4648规范实现了base64编码解码功能,包括标准方式以及URL/文件名称安全方式编码。本文通过示例演示如何编码和解码。 1. Base64 ...

    Golang Base64编码解码

    Golang内置支持Base64编码解码,Go的encoding/base64包遵照RFC 4648规范实现了base64编码解码功能,包括标准方式以及URL/文件名称安全方式编码。本文通过示例演示如何编码和解码。

    1. Base64 标准方式编码解码

    RFC 4648规范约定标准Base64对任何二进制数据使用US-ASCII字符子集进行编码,字符包括:A-Z, a-z, 0-9, +, and /

    编码示例:

    func encode() {
    	data := "hello world12345!?$*&()'-@~"
    
    	// Base64 Standard Encoding
    	sEnc := base64.StdEncoding.EncodeToString([]byte(data))
    	fmt.Println(sEnc) // aGVsbG8gd29ybGQxMjM0NSE/JComKCknLUB+
    }
    

    解码示例:

    func decode() {
    	data := "hello world12345!?$*&()'-@~"
    
    	sEnc := base64.StdEncoding.EncodeToString([]byte(data))
    
        // Base64 Standard Decoding
    	sDec, err := base64.StdEncoding.DecodeString(sEnc)
    	if err != nil {
    		fmt.Printf("Error decoding string: %s ", err.Error())
    		return
    	}
    
    	fmt.Println(string(sDec)) //hello world12345!?$*&()'-@~
    }
    

    2. URL和文件名安全编码解码

    URL和文件名安全方式是标准方式的变体,其输出用于URL和文件名。因为+/字符是标准Base64字符对URL和文件名编码不安全,变体即使用-代替+_(下划线)代替/

    编码示例:

    func encode() {
    	data := "hello world12345!?$*&()'-@~"
    
    	// Base64 Url Encoding
    	uEnc := base64.URLEncoding.EncodeToString([]byte(data))
    	fmt.Println(uEnc) // aGVsbG8gd29ybGQxMjM0NSE_JComKCknLUB-
    }
    

    解码示例:

    func decode() {
    	data := "hello world12345!?$*&()'-@~"
    
    	uEnc := base64.URLEncoding.EncodeToString([]byte(data))
    
        // Base64 Url Decoding
    	uDec, err := base64.URLEncoding.DecodeString(uEnc)
    	if err != nil {
    		fmt.Printf("Error decoding string: %s ", err.Error())
    		return
    	}
    	
    	fmt.Println(string(uDec)) // "hello world12345!?$*&()'-@~"
    }
    

    3. 无填充编码

    标准Base64编码对输出结果使用=进行填充。一般也建议使用填充方式,但一些场景无需填充。我们可以使用Raw方式编码即没有填充。

    无填充编码示例:

    func main() {
    	data := "abc!?$*&()'-@~"
    
    	// Base64 Encoding without Padding
    	swEnc := base64.RawStdEncoding.EncodeToString([]byte(data))
    	fmt.Println(swEnc) // YWJjIT8kKiYoKSctQH4
    
    	// Base64 Url Encoding without Padding
    	uwEnc := base64.RawURLEncoding.EncodeToString([]byte(data))
    	fmt.Println(uwEnc) //YWJjIT8kKiYoKSctQH4
    }
    

    4. 总结

    本文介绍了Golang内置支持Base64编码解码,确实很简单、很方便。

    展开全文
  • 一:url编码解码简介 url编码解码,又叫百分号编码,是统一资源定位(URL)编码方式。URL地址(常说网址)规定了常用地数字,字母可以直接使用,另外一批作为特殊用户字符也可以直接用(/,:@等),剩下的其它所有字符...

    一:url编码解码简介

    url编码解码又叫百分号编码,是统一资源定位(URL)编码方式。URL地址(常说网址)规定了常用地数字,字母可以直接使用,另外一批作为特殊用户字符也可以直接用(/,:@等),剩下的其它所有字符必须通过%xx编码处理。 现在已经成为一种规范了,基本所有程序语言都有这种编码,如js:有encodeURI、encodeURIComponent,PHP有 urlencode、urldecode等。编码方法很简单,在该字节ascii码的的16进制字符前面加%. 如 空格字符,ascii码是32,对应16进制是'20',那么urlencode编码结果是:%20

    二:在线转换工具

    网上有很多在线转换工具,可以搜“urlencode” 、“urldecode”

    下面这个不错(如无法使用可以搜其他的)。

    http://web.chacuo.net/charseturlencode

    http://www.atool.org/urlencode.php

    一般使用utf8编码,如果不行,也可以试试其他编码方式

    三:算法

    Python代码:

    #!/usr/bin/python
    #-*- coding: utf-8 -*-
    
    import urllib.parse 
    
    
    
    s="http://yz.chsi.com.cn/zsml/querySchAction.do?ssdm=61&dwmc=%E4%B8%AD%E5%9B%BD%E8%88%AA%E5%A4%A9%E7%A7%91%E6%8A%80%E9%9B%86%E5%9B%A2%E5%85%AC%E5%8F%B8%E7%AC%AC%E4%BA%94%E7%A0%94%E7%A9%B6%E9%99%A2%E8%A5%BF%E5%AE%89%E5%88%86%E9%99%A2&mldm=&mlmc=&yjxkdm=0809&xxfs=&zymc="
    
    data = urllib.parse.unquote(s)
    print (data)

     

    结果:

    下面这个是用C++实现的比较简单的计算,通用性不是太强,可以搜索其他的算法,也可以直接用Python的类库。

    URLEncode是这样编码的 
    1。数字和字母不变。
    2。空格变为"+"号。
    3。其他被编码成"%"加上他们的ascii的十六进制,规律是这样的
    比如“啊”字 Ascii的十六进制是B0A1——>%B0%A1(Note:它是每个字节前加个%)。
    */

    #include <iostream>
    #include <iostream>
    #include <string>
    #include <fstream>
    #include <ctype.h>
    #include <stdlib.h>
    
    using namespace std;
    typedef unsigned char BYTE;
    inline BYTE toHex(const BYTE &x)
    {
    	return x > 9 ? x + 55 : x + 48;
    }
    
    string urlEncoding(string &sIn)
    {
    	cout << "size:" << sIn.size() << endl;
    	string sOut;
    	for (int ix = 0; ix < sIn.size(); ix++)
    	{
    		BYTE buf[4];
    		memset(buf, 0, 4);
    		if (isalnum((BYTE)sIn[ix]))
    		{
    			buf[0] = sIn[ix];
    		}
    		else if (isspace((BYTE)sIn[ix]))
    		{
    			buf[0] = '+';
    		}
    		else
    		{
    			buf[0] = '%';
    			buf[1] = toHex((BYTE)sIn[ix] >> 4);
    			buf[2] = toHex((BYTE)sIn[ix] % 16);
    		}
    		sOut += (char *)buf;
    	}
    	return sOut;
    }
    int main(int argc, char *argv[])
    {
    	string src;
    	cout << "Please input characters." << endl;
    	cin >> src;
    	string sOut = urlEncoding(src);
    	cout << sOut << endl;
    	system("PAUSE");
    	return 0;
    }

     

    展开全文
  • Java:Base64编码解码

    千次阅读 2019-06-26 11:55:56
    Base64编码解码已经加入Java 8 类库的标准。 使用文档:https://www.runoob.com/java/java8-base64.html 编码解码示例: import java.util.Base64; import java.util.Base64.Decoder; public class Test { public...

    Base64编码解码已经加入Java 8 类库的标准。
    使用文档:https://www.runoob.com/java/java8-base64.html


    编码解码示例:

    import java.util.Base64;
    import java.util.Base64.Decoder;
    
    public class Test {
      public static void main(String[] args) throws Exception {
        String str = "锄禾日当午,汗滴禾下土。\n谁知盘中餐,粒粒皆辛苦。";
        
        String base64_1 = Base64.getEncoder().encodeToString(str.getBytes("utf-8"));
        System.out.println(base64_1);
        System.out.println("*******");
        
        String base64_2 = Base64.getMimeEncoder().encodeToString(str.getBytes("utf-8"));
        System.out.println(base64_2);
        System.out.println("*******");
    
        Decoder decoder = Base64.getMimeDecoder();
        
        byte[] bs_1 = decoder.decode(base64_1);
        System.out.println(new String(bs_1, "utf-8"));
        System.out.println("*******");
        
        byte[] bs_2 = decoder.decode(base64_2);
        System.out.println(new String(bs_2, "utf-8"));
      }
    }
    

    打印结果:

    6ZSE56a+5pel5b2T5Y2I77yM5rGX5ru056a+5LiL5Zyf44CCCuiwgeefpeebmOS4remkkO+8jOeykueykueahui+m+iLpuOAgg==
    *******
    6ZSE56a+5pel5b2T5Y2I77yM5rGX5ru056a+5LiL5Zyf44CCCuiwgeefpeebmOS4remkkO+8jOey
    kueykueahui+m+iLpuOAgg==
    *******
    锄禾日当午,汗滴禾下土。
    谁知盘中餐,粒粒皆辛苦。
    *******
    锄禾日当午,汗滴禾下土。
    谁知盘中餐,粒粒皆辛苦。
    
    展开全文
  • 基于 MATLAB 的 PCM 编码解码实现

    万次阅读 多人点赞 2019-01-12 12:32:53
    文章目录基于 MATLAB 的 PCM 编码解码实现抽样信号PCM 编码PCM 解码失真度分析 基于 MATLAB 的 PCM 编码解码实现 关于 PCM 的原理在此不过多解释,代码使用的是 A 律 13 折线法。 抽样信号 抽样信号的 MATLAB 代码...
  • JS编码解码对应C#编码解码

    千次阅读 2016-09-28 14:02:16
    escape不编码字符有69个:*,+,-,.,/,@,_,0-9,a-z,A-Z encodeURI不编码字符有82个:!,#,$,&,',(,),*,+,,,-,.,/,:,;,=,?,@,_,~,0-9,a-z,A-Z encodeURIComponent不编码字符有71个:!...
  • 这里把ExchangeCodec和DubboCodec放一起来讲解dubbo传输的底层协议组成以及它的编码解码过程。   传输协议 协议格式 协议头 :header 是16个字节的定长数据  = 2 //short类型的MAGIC = (short) 0xdabb + 1 //一个...
  • 视频编码解码基本知识

    千次阅读 2018-05-24 11:24:28
    最近在做摄像头视频的数据处理,得到了网络相机的.h264格式的数据,需要做解码处理,由于对视频的编码解码原理不太了解,因此查找资料总结一下 为什么要进行视频编码? 视频编码又称为视频压缩,伴随着用户对高清...
  • String字符串编码解码格式

    万次阅读 2018-10-10 18:04:14
    String字符串编码解码格式 String.getBytes()//方法是得到一个操作系统默认的编码格式的字节数组。 String.getBytes(String decode)//方法会根据指定的decode编码返回某字符串在该编码下的byte数组表示 new ...
  • Android编码解码及其原理

    千次阅读 2015-10-17 20:52:31
    android编码解码及其原理 Base64 URLEncoding Hex 编译
  • BASE64Decoder 对文件编码解码

    千次阅读 2017-08-09 17:02:30
    BASE64Decoder 对文件编码解码
  • Get请求与URL编码解码

    千次阅读 2018-03-20 18:11:37
    Get请求传参,与编码解码 @1 Get请求流程: 在get请求中,参数直接添加在了url后面,同url一起提交到服务器。 常用的url参数的格式为: http://ip:port/path/file?参数1=值1&amp;参数2=值2…. 多个参数之间...
  • js 编码解码 与 java编码解码

    千次阅读 2016-04-26 10:03:44
    encodeURI()与decodeURI()是成对来使用的,浏览器的地址栏有中文或其他英文字符的话,可能会出现不可预期的错误,或者地址栏避免出现中文的话,可以用encodeURI把非英文字符转化为英文编码,再用decodeURI把字符还原...
  • Java 字符串的编码解码

    千次阅读 2017-10-29 16:08:25
    结合别人的内容和自己的理解规范地整理出,做以笔记 一、认识编码 .编码:规定每个“字符”分别用一个...二、Java中常用的字符串的编码解码 1.将字符串转换成byte数组再恢复: byte[] getBytes(String charsetNam
  • 基础|URL编码解码原理及示例

    千次阅读 2015-12-01 16:53:42
    一:URL编码解码原理 什么是编码解码? 编码:是把字符转化为字节数组。 解码:是把字节数组转化为字符。 URL编码解码过程? 但有一种特殊的URL编码方式是把字符转化为字符,具体的规则是: 如果字符是西文字符,则...
  • Delphi中处理URL编码解码

    千次阅读 2015-08-22 16:15:06
    Delphi中处理URL编码解码
  • 编码解码 GStreamer

    千次阅读 2009-11-16 20:01:00
    编码解码 今天听了关于GStreamer的一个报告,讲到了GLib,讲到了编码解码,讲到了关于音频与视频上的很多东西,现在整理一下。 GStreamer,它是一种通用的多媒体处理库,可以使得多媒体处理更加容易。多媒体库,...
  • shell中base64编码解码的使用

    千次阅读 2020-02-20 18:56:45
    网上关于base64编码解码的工具有很多,但这里说的是一种可以直接在shell中运行的方法。 base64在shell中常用的方式如下: 1、base64编码 (1)base64 file 功能:从指定的文件file中读取数据,编码为base64的字符串...
  • java8 文件图片转base64 编码解码

    千次阅读 2018-08-16 14:08:20
    base64 编码解码工具类  import sun.misc.BASE64Encoder; import java.io.*; import java.nio.file.Files; import java.nio.file.Paths; import java.nio.file.StandardOpenOption; import java.util.Base64; ...
  • opencv 编码解码

    万次阅读 2019-09-20 11:38:34
    cv::imencode Mat数据编码成数据流 cv::imdecode 数据流解码成Mat demo int main() { cv::Mat src = cv::imread("E:\\Windowstest\\ConsoleApplication4\\ycy.jpg", 1); cv::Mat dst; std::vector <unsigned ...
  • 图像处理:编码解码处理 一张RGB图像可以看成一个三维的矩阵,矩阵中的每一个数表示了图像上不同位置,不同颜色的亮度。然而图像在存储时并不是直接记录 这些矩阵中的数字,而是记录经过压缩编码之后的结果。所以要...
  • Base64编码解码原理详解

    万次阅读 2016-06-01 00:51:58
    Base64编码解码原理详解1. Base64字符的组成部分 Base64所用字符: 0,1,2 ….9 A,B,C,D…Z a,b,c,d…z + / 对应ASCII: 48,49…58,65,66…90,97,98…122, 43,47 2. 10个数字,26个大写字母,26个小写字母,1个+...
  • HDMI_FPGA实现4K60TMDS编码解码之一

    千次阅读 2019-07-25 18:29:59
    hdmi1.4 tmds编码解码原理 一个HDMI包括三个TMDS 数据通道和一个 TMDS 时钟通道(像素时钟),如图所示 每一个 TMDS 时钟周期内,TMDS 数据通道上会发送一个 10 位的字符信息。 信号源编码逻辑的输入数据包括控制...
  • 其实初次我接触格雷码的时候,头大的不行,这个东西的性质太多了,想要产生一个格雷码,好像也只有通过动态规划或者递归的方式实现,第一次做格雷编码解码问题的时候,只能跪倒在各位大佬面前,然后把它抛在了脑后,...
  • 红外遥控器快速编码解码(NEC)

    千次阅读 2020-06-29 10:46:22
    红外遥控器快速编码解码 NEC编解码模块 红外遥控简介NEC编码红外编解码模块接线说明串口查看数据插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建...
  • JSP页面请求响应过程中的编码解码

    千次阅读 2017-02-19 17:35:51
    该编简要讲述:JSP页面传输过程中,浏览器与服务器的编码解码以及HTTP协议对URL进行的编码解码。无意间在网络上看到这样一个问题,让我不得其解。查询了诸多资料,稍有眉目。问题如下:所有的JSP页面的编码都是UTF-8...
  • 在js编码解码中我们可以使用decodeURIComponent()与encodeURIComponent()函数进行处理,下面我们一起来看一个简单编码解码的例子吧。 javascript(UrlDecodedecodeURIComponent())这个函数名称实在太常了...
  • 国外视频编码解码好书

    千次阅读 2011-05-10 01:02:00
    视频编码解码网站:www.vcodex.com<br />视频编码解码好书: The H.264 Advanced Video Compression Standard Video Codec Design H.264 and MPEG-4 Video Compression  
  • H264是目前最常用的视频压缩格式之一,可以将视频、图片、音频等转换...在Android里,最常用的视频编码解码用的API就是mediacodec了,可以进行多种格式的硬解码,也能和mediamuxer一起使用实现音视频文件的编辑(结合Me
  • Logisim海明编码解码实验

    千次阅读 热门讨论 2020-04-16 10:59:56
    海明编码 思路 校验位分别位于2^i位(i=0,1…),故可得 p6为总校验位 电路图 海明解码 思路 引入纠错码G1,G2,G3,G4,G5 第i个码检验它之前检验的值 设计的电路图可以纠错一个字,检查两位错,通过使用异或非门来...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 345,391
精华内容 138,156
关键字:

编码解码