当前位置： 首页 > news >正文

C#，哈夫曼编码（Huffman Code）压缩（Compress ）与解压缩（Decompress）算法与源代码

news 2026/2/8 14:40:32

 David A. Huffman

1 哈夫曼编码简史（Huffman code）

1951年，哈夫曼和他在MIT信息论的同学需要选择是完成学期报告还是期末考试。导师Robert M. Fano给他们的学期报告的题目是，寻找最有效的二进制编码。由于无法证明哪个已有编码是最有效的，哈夫曼放弃对已有编码的研究，转向新的探索，最终发现了基于有序频率二叉树编码的想法，并很快证明了这个方法是最有效的。由于这个算法，学生终于青出于蓝，超过了他那曾经和信息论创立者香农共同研究过类似编码的导师。哈夫曼使用自底向上的方法构建二叉树，避免了次优算法Shannon-Fano编码的最大弊端──自顶向下构建树。
1952年，David A. Huffman在麻省理工攻读博士时发表了《一种构建极小多余编码的方法》，一文，它一般就叫做Huffman编码。A Method for the Construction of Minimum-Redundancy Codesicon-default.png?t=N7T8https://www.ias.ac.in/article/fulltext/reso/011/02/0091-0099
Huffman在1952年根据香农（Shannon）在1948年和范若（Fano）在1949年阐述的这种编码思想提出了一种不定长编码的方法，也称霍夫曼（Huffman）编码。霍夫曼编码的基本方法是先对图像数据扫描一遍，计算出各种像素出现的概率，按概率的大小指定不同长度的唯一码字，由此得到一张该图像的霍夫曼码表。编码后的图像数据记录的是每个像素的码字，而码字与实际像素值的对应关系记录在码表中。

2 赫夫曼编码

赫夫曼编码是可变字长编码(VLC)的一种。 Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长 度最短的码字，有时称之为最佳编码，一般就称Huffman编码。下面引证一个定理，该定理保证了按字符出现概率分配码长，可使平均码长最短。

3 源程序

using System;
using System.IO;
using System.Text;
using System.Linq;
using System.Collections;
using System.Collections.Generic;

namespace Legalsoft.Truffer.Algorithm
{
    /// <summary>
    /// 哈夫曼编码的压缩与解压缩
    /// </summary>
    public class HuffmanCompressor
    {
        private HuffmanNode oRootHuffmanNode { get; set; } = null;
        private List<HuffmanNode> oValueHuffmanNodes { get; set; } = null;

        private List<HuffmanNode> BuildBinaryTree(string Value)
        {
            List<HuffmanNode> oHuffmanNodes = GetInitialNodeList();

            Value.ToList().ForEach(m => oHuffmanNodes[m].Weight++);

            oHuffmanNodes = oHuffmanNodes
                .Where(m => (m.Weight > 0))
                .OrderBy(m => (m.Weight))
                .ThenBy(m => (m.Value))
                .ToList();

            oHuffmanNodes = UpdateNodeParents(oHuffmanNodes);

            oRootHuffmanNode = oHuffmanNodes[0];
            oHuffmanNodes.Clear();

            SortNodes(oRootHuffmanNode, oHuffmanNodes);

            return oHuffmanNodes;
        }

        public void Compress(string FileName)
        {
            FileInfo oFileInfo = new FileInfo(FileName);

            if (oFileInfo.Exists == true)
            {
                string sFileContents = "";

                using (StreamReader oStreamReader = new StreamReader(File.OpenRead(FileName)))
                {
                    sFileContents = oStreamReader.ReadToEnd();
                }

                List<HuffmanNode> oHuffmanNodes = BuildBinaryTree(sFileContents);

                oValueHuffmanNodes = oHuffmanNodes
                    .Where(m => (m.Value.HasValue == true))
                    .OrderBy(m => (m.BinaryWord))
                    .ToList();

                Dictionary<char, string> oCharToBinaryWordDictionary = new Dictionary<char, string>();
                foreach (HuffmanNode oHuffmanNode in oValueHuffmanNodes)
                {
                    oCharToBinaryWordDictionary.Add(oHuffmanNode.Value.Value, oHuffmanNode.BinaryWord);
                }

                StringBuilder oStringBuilder = new StringBuilder();
                List<byte> oByteList = new List<byte>();
                for (int i = 0; i < sFileContents.Length; i++)
                {
                    string sWord = "";

                    oStringBuilder.Append(oCharToBinaryWordDictionary[sFileContents[i]]);

                    while (oStringBuilder.Length >= 8)
                    {
                        sWord = oStringBuilder.ToString().Substring(0, 8);

                        oStringBuilder.Remove(0, sWord.Length);
                    }

                    if (String.IsNullOrEmpty(sWord) == false)
                    {
                        oByteList.Add(Convert.ToByte(sWord, 2));
                    }
                }

                if (oStringBuilder.Length > 0)
                {
                    string sWord = oStringBuilder.ToString();

                    if (String.IsNullOrEmpty(sWord) == false)
                    {
                        oByteList.Add(Convert.ToByte(sWord, 2));
                    }
                }

                string sCompressedFileName = Path.Combine(oFileInfo.Directory.FullName, String.Format("{0}.compressed", oFileInfo.Name.Replace(oFileInfo.Extension, "")));
                if (File.Exists(sCompressedFileName) == true)
                {
                    File.Delete(sCompressedFileName);
                }

                using (FileStream oFileStream = File.OpenWrite(sCompressedFileName))
                {
                    oFileStream.Write(oByteList.ToArray(), 0, oByteList.Count);
                }
            }
        }

        public void Decompress(string FileName)
        {
            FileInfo oFileInfo = new FileInfo(FileName);

            if (oFileInfo.Exists == true)
            {
                string sCompressedFileName = String.Format("{0}.compressed", oFileInfo.FullName.Replace(oFileInfo.Extension, ""));

                byte[] oBuffer = null;
                using (FileStream oFileStream = File.OpenRead(sCompressedFileName))
                {
                    oBuffer = new byte[oFileStream.Length];
                    oFileStream.Read(oBuffer, 0, oBuffer.Length);
                }

                HuffmanNode oZeroHuffmanNode = oRootHuffmanNode;
                while (oZeroHuffmanNode.Left != null)
                {
                    oZeroHuffmanNode = oZeroHuffmanNode.Left;
                }

                HuffmanNode oCurrentHuffmanNode = null;
                StringBuilder oStringBuilder = new StringBuilder();

                for (int i = 0; i < oBuffer.Length; i++)
                {
                    string sBinaryWord = "";
                    byte oByte = oBuffer[i];

                    if (oByte == 0)
                    {
                        sBinaryWord = oZeroHuffmanNode.BinaryWord;
                    }
                    else
                    {
                        sBinaryWord = Convert.ToString(oByte, 2);
                    }

                    if ((sBinaryWord.Length < 8) && (i < (oBuffer.Length - 1)))
                    {
                        StringBuilder oBinaryStringBuilder = new StringBuilder(sBinaryWord);
                        while (oBinaryStringBuilder.Length < 8)
                        {
                            oBinaryStringBuilder.Insert(0, "0");
                        }

                        sBinaryWord = oBinaryStringBuilder.ToString();
                    }

                    for (int j = 0; j < sBinaryWord.Length; j++)
                    {
                        char cValue = sBinaryWord[j];

                        if (oCurrentHuffmanNode == null)
                        {
                            oCurrentHuffmanNode = oRootHuffmanNode;
                        }

                        if (cValue == '0')
                        {
                            oCurrentHuffmanNode = oCurrentHuffmanNode.Left;
                        }
                        else
                        {
                            oCurrentHuffmanNode = oCurrentHuffmanNode.Right;
                        }

                        if ((oCurrentHuffmanNode.Left == null) && (oCurrentHuffmanNode.Right == null))
                        {
                            oStringBuilder.Append(oCurrentHuffmanNode.Value.Value);
                            oCurrentHuffmanNode = null;
                        }
                    }
                }

                string sUncompressedFileName = Path.Combine(oFileInfo.Directory.FullName, String.Format("{0}.uncompressed", oFileInfo.Name.Replace(oFileInfo.Extension, "")));

                if (File.Exists(sUncompressedFileName) == true)
                {
                    File.Delete(sUncompressedFileName);
                }

                using (StreamWriter oStreamWriter = new StreamWriter(File.OpenWrite(sUncompressedFileName)))
                {
                    oStreamWriter.Write(oStringBuilder.ToString());
                }
            }
        }

        private static List<HuffmanNode> GetInitialNodeList()
        {
            List<HuffmanNode> oGetInitialNodeList = new List<HuffmanNode>();

            for (int i = Char.MinValue; i < Char.MaxValue; i++)
            {
                oGetInitialNodeList.Add(new HuffmanNode((char)(i)));
            }

            return oGetInitialNodeList;
        }

        private static void SortNodes(HuffmanNode Node, List<HuffmanNode> Nodes)
        {
            if (Nodes.Contains(Node) == false)
            {
                Nodes.Add(Node);
            }

            if (Node.Left != null)
            {
                SortNodes(Node.Left, Nodes);
            }

            if (Node.Right != null)
            {
                SortNodes(Node.Right, Nodes);
            }
        }

        private static List<HuffmanNode> UpdateNodeParents(List<HuffmanNode> Nodes)
        {
            while (Nodes.Count > 1)
            {
                int iOperations = (Nodes.Count / 2);
                for (int iOperation = 0, i = 0, j = 1; iOperation < iOperations; iOperation++, i += 2, j += 2)
                {
                    if (j < Nodes.Count)
                    {
                        HuffmanNode oParentHuffmanNode = new HuffmanNode(Nodes[i], Nodes[j]);
                        Nodes.Add(oParentHuffmanNode);

                        Nodes[i] = null;
                        Nodes[j] = null;
                    }
                }

                Nodes = Nodes
                    .Where(m => (m != null))
                    .OrderBy(m => (m.Weight))
                    .ToList();
            }

            return Nodes;
        }
    }

    public class HuffmanNode
    {
        private string sBinaryWord { get; set; } = "";
        private bool bIsLeftNode { get; set; } = false;
        private bool bIsRightNode { get; set; } = false;
        private HuffmanNode oLeft { get; set; } = null;
        private HuffmanNode oParent { get; set; } = null;
        private HuffmanNode oRight { get; set; } = null;
        private char? cValue { get; set; } = ' ';
        private int iWeight { get; set; } = 0;

        public HuffmanNode()
        {
        }

        public HuffmanNode(char Value)
        {
            cValue = Value;
        }

        public HuffmanNode(HuffmanNode Left, HuffmanNode Right)
        {
            oLeft = Left;
            oLeft.oParent = this;
            oLeft.bIsLeftNode = true;

            oRight = Right;
            oRight.oParent = this;
            oRight.bIsRightNode = true;

            iWeight = (oLeft.Weight + oRight.Weight);
        }

        public string BinaryWord
        {
            get
            {
                string sReturnValue = "";

                if (String.IsNullOrEmpty(sBinaryWord) == true)
                {
                    StringBuilder oStringBuilder = new StringBuilder();

                    HuffmanNode oHuffmanNode = this;

                    while (oHuffmanNode != null)
                    {
                        if (oHuffmanNode.bIsLeftNode == true)
                        {
                            oStringBuilder.Insert(0, "0");
                        }

                        if (oHuffmanNode.bIsRightNode == true)
                        {
                            oStringBuilder.Insert(0, "1");
                        }

                        oHuffmanNode = oHuffmanNode.oParent;
                    }

                    sReturnValue = oStringBuilder.ToString();
                    sBinaryWord = sReturnValue;
                }
                else
                {
                    sReturnValue = sBinaryWord;
                }

                return sReturnValue;
            }
        }

        public HuffmanNode Left
        {
            get
            {
                return oLeft;
            }
        }

        public HuffmanNode Parent
        {
            get
            {
                return oParent;
            }
        }

        public HuffmanNode Right
        {
            get
            {
                return oRight;
            }
        }

        public char? Value
        {
            get
            {
                return cValue;
            }
        }

        public int Weight
        {
            get
            {
                return iWeight;
            }
            set
            {
                iWeight = value;
            }
        }

        public static int BinaryStringToInt32(string Value)
        {
            int iBinaryStringToInt32 = 0;

            for (int i = (Value.Length - 1), j = 0; i >= 0; i--, j++)
            {
                iBinaryStringToInt32 += ((Value[j] == '0' ? 0 : 1) * (int)(Math.Pow(2, i)));
            }

            return iBinaryStringToInt32;
        }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();

            if (cValue.HasValue == true)
            {
                sb.AppendFormat("'{0}' ({1}) - {2} ({3})", cValue.Value, iWeight, BinaryWord, BinaryStringToInt32(BinaryWord));
            }
            else
            {
                if ((oLeft != null) && (oRight != null))
                {
                    if ((oLeft.Value.HasValue == true) && (oRight.Value.HasValue == true))
                    {
                        sb.AppendFormat("{0} + {1} ({2})", oLeft.Value, oRight.Value, iWeight);
                    }
                    else
                    {
                        sb.AppendFormat("{0}, {1} - ({2})", oLeft, oRight, iWeight);
                    }
                }
                else
                {
                    sb.Append(iWeight);
                }
            }

            return sb.ToString();
        }
    }
}
 

4 源代码

using System;
using System.IO;
using System.Text;
using System.Linq;
using System.Collections;
using System.Collections.Generic;namespace Legalsoft.Truffer.Algorithm
{/// <summary>/// 哈夫曼编码的压缩与解压缩/// </summary>public class HuffmanCompressor{private HuffmanNode oRootHuffmanNode { get; set; } = null;private List<HuffmanNode> oValueHuffmanNodes { get; set; } = null;private List<HuffmanNode> BuildBinaryTree(string Value){List<HuffmanNode> oHuffmanNodes = GetInitialNodeList();Value.ToList().ForEach(m => oHuffmanNodes[m].Weight++);oHuffmanNodes = oHuffmanNodes.Where(m => (m.Weight > 0)).OrderBy(m => (m.Weight)).ThenBy(m => (m.Value)).ToList();oHuffmanNodes = UpdateNodeParents(oHuffmanNodes);oRootHuffmanNode = oHuffmanNodes[0];oHuffmanNodes.Clear();SortNodes(oRootHuffmanNode, oHuffmanNodes);return oHuffmanNodes;}public void Compress(string FileName){FileInfo oFileInfo = new FileInfo(FileName);if (oFileInfo.Exists == true){string sFileContents = "";using (StreamReader oStreamReader = new StreamReader(File.OpenRead(FileName))){sFileContents = oStreamReader.ReadToEnd();}List<HuffmanNode> oHuffmanNodes = BuildBinaryTree(sFileContents);oValueHuffmanNodes = oHuffmanNodes.Where(m => (m.Value.HasValue == true)).OrderBy(m => (m.BinaryWord)).ToList();Dictionary<char, string> oCharToBinaryWordDictionary = new Dictionary<char, string>();foreach (HuffmanNode oHuffmanNode in oValueHuffmanNodes){oCharToBinaryWordDictionary.Add(oHuffmanNode.Value.Value, oHuffmanNode.BinaryWord);}StringBuilder oStringBuilder = new StringBuilder();List<byte> oByteList = new List<byte>();for (int i = 0; i < sFileContents.Length; i++){string sWord = "";oStringBuilder.Append(oCharToBinaryWordDictionary[sFileContents[i]]);while (oStringBuilder.Length >= 8){sWord = oStringBuilder.ToString().Substring(0, 8);oStringBuilder.Remove(0, sWord.Length);}if (String.IsNullOrEmpty(sWord) == false){oByteList.Add(Convert.ToByte(sWord, 2));}}if (oStringBuilder.Length > 0){string sWord = oStringBuilder.ToString();if (String.IsNullOrEmpty(sWord) == false){oByteList.Add(Convert.ToByte(sWord, 2));}}string sCompressedFileName = Path.Combine(oFileInfo.Directory.FullName, String.Format("{0}.compressed", oFileInfo.Name.Replace(oFileInfo.Extension, "")));if (File.Exists(sCompressedFileName) == true){File.Delete(sCompressedFileName);}using (FileStream oFileStream = File.OpenWrite(sCompressedFileName)){oFileStream.Write(oByteList.ToArray(), 0, oByteList.Count);}}}public void Decompress(string FileName){FileInfo oFileInfo = new FileInfo(FileName);if (oFileInfo.Exists == true){string sCompressedFileName = String.Format("{0}.compressed", oFileInfo.FullName.Replace(oFileInfo.Extension, ""));byte[] oBuffer = null;using (FileStream oFileStream = File.OpenRead(sCompressedFileName)){oBuffer = new byte[oFileStream.Length];oFileStream.Read(oBuffer, 0, oBuffer.Length);}HuffmanNode oZeroHuffmanNode = oRootHuffmanNode;while (oZeroHuffmanNode.Left != null){oZeroHuffmanNode = oZeroHuffmanNode.Left;}HuffmanNode oCurrentHuffmanNode = null;StringBuilder oStringBuilder = new StringBuilder();for (int i = 0; i < oBuffer.Length; i++){string sBinaryWord = "";byte oByte = oBuffer[i];if (oByte == 0){sBinaryWord = oZeroHuffmanNode.BinaryWord;}else{sBinaryWord = Convert.ToString(oByte, 2);}if ((sBinaryWord.Length < 8) && (i < (oBuffer.Length - 1))){StringBuilder oBinaryStringBuilder = new StringBuilder(sBinaryWord);while (oBinaryStringBuilder.Length < 8){oBinaryStringBuilder.Insert(0, "0");}sBinaryWord = oBinaryStringBuilder.ToString();}for (int j = 0; j < sBinaryWord.Length; j++){char cValue = sBinaryWord[j];if (oCurrentHuffmanNode == null){oCurrentHuffmanNode = oRootHuffmanNode;}if (cValue == '0'){oCurrentHuffmanNode = oCurrentHuffmanNode.Left;}else{oCurrentHuffmanNode = oCurrentHuffmanNode.Right;}if ((oCurrentHuffmanNode.Left == null) && (oCurrentHuffmanNode.Right == null)){oStringBuilder.Append(oCurrentHuffmanNode.Value.Value);oCurrentHuffmanNode = null;}}}string sUncompressedFileName = Path.Combine(oFileInfo.Directory.FullName, String.Format("{0}.uncompressed", oFileInfo.Name.Replace(oFileInfo.Extension, "")));if (File.Exists(sUncompressedFileName) == true){File.Delete(sUncompressedFileName);}using (StreamWriter oStreamWriter = new StreamWriter(File.OpenWrite(sUncompressedFileName))){oStreamWriter.Write(oStringBuilder.ToString());}}}private static List<HuffmanNode> GetInitialNodeList(){List<HuffmanNode> oGetInitialNodeList = new List<HuffmanNode>();for (int i = Char.MinValue; i < Char.MaxValue; i++){oGetInitialNodeList.Add(new HuffmanNode((char)(i)));}return oGetInitialNodeList;}private static void SortNodes(HuffmanNode Node, List<HuffmanNode> Nodes){if (Nodes.Contains(Node) == false){Nodes.Add(Node);}if (Node.Left != null){SortNodes(Node.Left, Nodes);}if (Node.Right != null){SortNodes(Node.Right, Nodes);}}private static List<HuffmanNode> UpdateNodeParents(List<HuffmanNode> Nodes){while (Nodes.Count > 1){int iOperations = (Nodes.Count / 2);for (int iOperation = 0, i = 0, j = 1; iOperation < iOperations; iOperation++, i += 2, j += 2){if (j < Nodes.Count){HuffmanNode oParentHuffmanNode = new HuffmanNode(Nodes[i], Nodes[j]);Nodes.Add(oParentHuffmanNode);Nodes[i] = null;Nodes[j] = null;}}Nodes = Nodes.Where(m => (m != null)).OrderBy(m => (m.Weight)).ToList();}return Nodes;}}public class HuffmanNode{private string sBinaryWord { get; set; } = "";private bool bIsLeftNode { get; set; } = false;private bool bIsRightNode { get; set; } = false;private HuffmanNode oLeft { get; set; } = null;private HuffmanNode oParent { get; set; } = null;private HuffmanNode oRight { get; set; } = null;private char? cValue { get; set; } = ' ';private int iWeight { get; set; } = 0;public HuffmanNode(){}public HuffmanNode(char Value){cValue = Value;}public HuffmanNode(HuffmanNode Left, HuffmanNode Right){oLeft = Left;oLeft.oParent = this;oLeft.bIsLeftNode = true;oRight = Right;oRight.oParent = this;oRight.bIsRightNode = true;iWeight = (oLeft.Weight + oRight.Weight);}public string BinaryWord{get{string sReturnValue = "";if (String.IsNullOrEmpty(sBinaryWord) == true){StringBuilder oStringBuilder = new StringBuilder();HuffmanNode oHuffmanNode = this;while (oHuffmanNode != null){if (oHuffmanNode.bIsLeftNode == true){oStringBuilder.Insert(0, "0");}if (oHuffmanNode.bIsRightNode == true){oStringBuilder.Insert(0, "1");}oHuffmanNode = oHuffmanNode.oParent;}sReturnValue = oStringBuilder.ToString();sBinaryWord = sReturnValue;}else{sReturnValue = sBinaryWord;}return sReturnValue;}}public HuffmanNode Left{get{return oLeft;}}public HuffmanNode Parent{get{return oParent;}}public HuffmanNode Right{get{return oRight;}}public char? Value{get{return cValue;}}public int Weight{get{return iWeight;}set{iWeight = value;}}public static int BinaryStringToInt32(string Value){int iBinaryStringToInt32 = 0;for (int i = (Value.Length - 1), j = 0; i >= 0; i--, j++){iBinaryStringToInt32 += ((Value[j] == '0' ? 0 : 1) * (int)(Math.Pow(2, i)));}return iBinaryStringToInt32;}public override string ToString(){StringBuilder sb = new StringBuilder();if (cValue.HasValue == true){sb.AppendFormat("'{0}' ({1}) - {2} ({3})", cValue.Value, iWeight, BinaryWord, BinaryStringToInt32(BinaryWord));}else{if ((oLeft != null) && (oRight != null)){if ((oLeft.Value.HasValue == true) && (oRight.Value.HasValue == true)){sb.AppendFormat("{0} + {1} ({2})", oLeft.Value, oRight.Value, iWeight);}else{sb.AppendFormat("{0}, {1} - ({2})", oLeft, oRight, iWeight);}}else{sb.Append(iWeight);}}return sb.ToString();}}
}

相关文章：

C#，哈夫曼编码（Huffman Code）压缩（Compress ）与解压缩（Decompress）算法与源代码

David A. Huffman 1 哈夫曼编码简史&#xff08;Huffman code&#xff09; 1951年&#xff0c;哈夫曼和他在MIT信息论的同学需要选择是完成学期报告还是期末考试。导师Robert M. Fano给他们的学期报告的题目是&#xff0c;寻找最有效的二进制编码。由于无法证明哪个已有编码是…...

编程日记 2024/3/4 16:04:09

JS 对象数组排序方法测试

输出 一.Array.prototype.sort() 1.默认排序 sort() sort() 方法就地对数组的元素进行排序&#xff0c;并返回对相同数组的引用。默认排序是将元素转换为字符串&#xff0c;然后按照它们的 UTF-16 码元值升序排序。 由于它取决于具体实现&#xff0c;因此无法保证排序的时…...

编程日记 2024/3/4 16:02:05

【计算机考研】408学到什么程度才能考130？

408考130要比考研数学考130难的多 我想大部分考过408的考生都是这么认为的。408的难点在于他涉及的范围太广了&#xff0c;首先如果你要备考408&#xff0c;你要准备四门课程&#xff0c;分别是数据结构&#xff0c;计算机组成原理&#xff0c;操作系统和计算机网络。 这四门…...

编程日记 2024/3/4 16:00:03

“智农”-农业物联网可视化

大棚可视化|设施农业可视化|农业元宇宙|农业数字孪生|大棚物联网|大棚数字孪生|农业一体化管控平台|智慧农业可视化|智农|农业物联网可视化|农业物联网数字孪生|智慧农业|大棚三维可视化|智慧大棚可视化|智慧大棚|农业智慧园区|数字农业|数字大棚|农业大脑|智慧牧业数字孪生|智…...

编程日记 2024/3/4 15:59:01

day03-网络编程

1>TCP机械臂测试 #include<myhead.h> #define SER_IP "10.211.55.11" #define SER_PORT 8888 #define CLI_IP "10.211.55.9" #define CLI_PORT 6666 //客户端 int main(int argc, const char *argv[]) {//1、创建用于通信的套接字文件描述符int …...

编程日记 2024/3/4 15:55:58

Java反射，动态代理。笔记

1.pathClass Loader 和 Dex ClassLoader 在Android 5.0以下的版本中，两者之间的区别为： DexClassLoader：可加载jar、apk和dex」可以从SD卡中加载PathClassLoader：只能加载已安裝到系統中（即/data/app目录下）的apk文件但是随着Android版本的升级，到Android …...

编程日记 2024/3/4 15:53:56

作为团队开发组长你需要做的：

当你需要开始团队开发时&#xff0c;以下是一些你可能需要知道和使用的工具、实践和原则&#xff1a; 1. 版本控制系统 (VCS): 使用版本控制系统&#xff08;如Git&#xff09;来管理代码。这能确保团队成员协同工作时能够跟踪和管理代码的变更。创建分支进行开发&#xff0c…...

编程日记 2024/3/4 15:52:55

Windows安装Neo4j数据库教程（3.X版本）

安装java的jdk&#xff08;jdk1.8仅支持Neo4j 3.X版本&#xff09;去 Index of /doc/neo4j/ 下载目标版本的Windows zip安装包将安装包解压到任意目录&#xff0c;并记住解压后带版本号的文件夹路径添加系统环境变量&#xff0c;变量名&#xff1a;NEO4J_HOME&#xff0c;变量值…...

编程日记 2024/3/4 15:50:52

无人机飞行控制系统技术，四旋翼无人机控制系统建模技术详解

物理建模是四旋翼无人机控制系统建模的基础&#xff0c;主要涉及到无人机的物理特性和运动学特性。物理建模的目的是将无人机的运动与输入信号&#xff08;如控制电压&#xff09;之间的关系进行数学描述。 四旋翼无人直升机是具有四个输入力和六个坐标输出的欠驱动动力学旋翼…...

编程日记 2024/3/4 15:46:48

程序员的金三银四求职宝典：如何在关键时期脱颖而出？

个人主页&#xff1a;17_Kevin-CSDN博客 随着春天的脚步渐近&#xff0c;程序员们的求职热潮也随之而来。在这个被称为“金三银四”的招聘季&#xff0c;如何从众多求职者中脱颖而出&#xff0c;成为了许多程序员关注的焦点。本文将为你提供一份全面的求职宝典&#xff0c;助你…...

编程日记 2024/3/4 15:45:47

分享经典、现代和前沿软件工程课程

随着信息技术的发展&#xff0c;软件已经深入到人类社会生产和生活的各个方面。软件工程是将工程化的方法运用到软件的开发、运行和维护之中&#xff0c;以达到提高软件质量&#xff0c;降低开发成本的目的。软件工程已经成为当今最活跃、最热门的学科之一。 本次软件工程MOOC课…...

编程日记 2024/3/4 15:44:46

网络工程师笔记3

IP地址类型 A类 255.0.0.0B类 255.255.0.0C类 255.255.255.0D类 E类 子网掩码&#xff1a;从左到右连续的确定网络位 2-4-8-16-32-64-128-256 128 &#xff1a; 1000 0000 64 &#xff1a; 0100 0000 32 &#xff1a; 0010 0000 16 &#xff1a; 0001 0000 8 &am…...

编程日记 2024/3/4 15:43:45

【菜鸟入门！】Matlab零基础快速入门教程

数学建模竞赛中&#xff0c;编程软件是必不可缺少的&#xff0c;比如大家都熟知的MATLAB多数同学们都会经常用到&#xff0c;今天给大家介绍一些MATLAB的基本元素&#xff0c;希望帮助大家更好的掌握编写基本的函数&#xff01; 变量和数组 MATLAB 程序的基本数据单元是数组。一…...

编程日记 2024/3/4 15:41:42

数据中心GPU集群高性能组网技术分析

数据中心GPU集群组网技术是指将多个GPU设备连接在一起&#xff0c;形成一个高性能计算的集群系统。通过集群组网技术&#xff0c;可以实现多个GPU设备之间的协同计算&#xff0c;提供更大规模的计算能力&#xff0c;适用于需要大规模并行计算的应用场景。 常用的组网技术&…...

编程日记 2024/3/4 15:40:41

go垃圾回收

1 go 垃圾回收变更 Go 语言的垃圾回收器&#xff08;GC&#xff09;自其诞生以来一直在不断演进和优化&#xff0c;以提高性能、减少暂停时间和对程序执行的影响。以下是一些关键的改进和变更点&#xff1a; 并发标记周期&#xff1a; Go 语言从一开始就采用了并发标记&#xf…...

编程日记 2024/3/4 15:39:39

如何做代币分析：以 LEO 币为例

作者&#xff1a; lesleyfootprint.network 编译&#xff1a;cicifootprint.network 数据源&#xff1a;LEO 代币仪表板 &#xff08;仅包括以太坊数据&#xff09; 在加密货币和数字资产领域&#xff0c;代币分析起着至关重要的作用。代币分析指的是深入研究与代币相关的数…...

编程日记 2024/3/4 15:38:38

数制和码制

目录 几种常见的数制 数制 基数 位权 常见的四种数制 十进制数 二进制数 八进制数 十六进制数 不同进制数的相互转换 例如 例如 编码 二-十进制码 例如 格雷码 例如 原码、反码和补码 几种常见的数制 关键术语 数制&#xff1a;以一组固定的符号和统一的规则来表示数值…...

编程日记 2024/3/4 15:29:24

Git Bash中安装tree

文章目录 问题描述解决办法A备选办法BRef 问题描述 在Git Bash中使用tree报错&#xff1a; tree # bash: tree: command not found解决办法A 下载二进制文件&#xff1a; https://gnuwin32.sourceforge.net/packages/tree.htm -> 选binary。下载后解压.zip 把解压后的tre…...

编程日记 2024/3/4 15:28:23

java开源 VR全景商城 saas商城 b2b2c商城 o2o商城 积分商城 秒杀商城 拼团商城 分销商城 短视频商城 小程序商城搭建

1. 涉及平台 平台管理、商家端&#xff08;PC端、手机端&#xff09;、买家平台&#xff08;H5/公众号、小程序、APP端&#xff08;IOS/Android&#xff09;、微服务平台&#xff08;业务服务&#xff09; 2. 核心架构 Spring Cloud、Spring Boot、Mybatis、Redis 3. 前端框架…...

编程日记 2024/3/4 15:26:20

C++练手题系列一

第 1 题 【 问答题 】 • 有多少种二叉树 输入n(1<n<13)&#xff0c;求n个结点的二叉树有多少种形态 时间限制&#xff1a;1000 内存限制&#xff1a;65536 输入 整数n 输出答案 样例输入 3 样例输出 5 第 2 题 【 问答题 】 • 城堡问题 1 2 3 4 5 6 7 ################…...

编程日记 2024/3/4 15:25:19

Vim 调用外部命令学习笔记

Vim 外部命令集成完全指南 文章目录 Vim 外部命令集成完全指南核心概念理解命令语法解析语法对比 常用外部命令详解文本排序与去重文本筛选与搜索高级 grep 搜索技巧文本替换与编辑字符处理高级文本处理编程语言处理其他实用命令 范围操作示例指定行范围处理复合命令示例 实用技…...

编程新知 2025/11/16 8:24:16

Chapter03-Authentication vulnerabilities

文章目录 1. 身份验证简介1.1 What is authentication1.2 difference between authentication and authorization1.3 身份验证机制失效的原因1.4 身份验证机制失效的影响 2. 基于登录功能的漏洞2.1 密码爆破2.2 用户名枚举2.3 有缺陷的暴力破解防护2.3.1 如果用户登录尝试失败次…...

编程新知 2026/2/7 4:57:53

基于距离变化能量开销动态调整的WSN低功耗拓扑控制开销算法matlab仿真

目录 1.程序功能描述 2.测试软件版本以及运行结果展示 3.核心程序 4.算法仿真参数 5.算法理论概述 6.参考文献 7.完整程序 1.程序功能描述 通过动态调整节点通信的能量开销&#xff0c;平衡网络负载&#xff0c;延长WSN生命周期。具体通过建立基于距离的能量消耗模型&am…...

编程新知 2026/2/6 5:38:46

IGP（Interior Gateway Protocol，内部网关协议）

IGP&#xff08;Interior Gateway Protocol&#xff0c;内部网关协议&#xff09; 是一种用于在一个自治系统&#xff08;AS&#xff09;内部传递路由信息的路由协议&#xff0c;主要用于在一个组织或机构的内部网络中决定数据包的最佳路径。与用于自治系统之间通信的 EGP&…...

编程新知 2025/10/12 11:54:26

深入理解JavaScript设计模式之单例模式

目录 什么是单例模式为什么需要单例模式常见应用场景包括 单例模式实现透明单例模式实现不透明单例模式用代理实现单例模式javaScript中的单例模式使用命名空间使用闭包封装私有变量 惰性单例通用的惰性单例 结语 什么是单例模式 单例模式&#xff08;Singleton Pattern&#…...

编程新知 2026/1/31 17:09:43

【Go】3、Go语言进阶与依赖管理

前言 本系列文章参考自稀土掘金上的 【字节内部课】公开课&#xff0c;做自我学习总结整理。 Go语言并发编程 Go语言原生支持并发编程&#xff0c;它的核心机制是 Goroutine 协程、Channel 通道&#xff0c;并基于CSP&#xff08;Communicating Sequential Processes&#xff0…...

编程新知 2025/10/7 0:32:40

【HTTP三个基础问题】

面试官您好&#xff01;HTTP是超文本传输协议&#xff0c;是互联网上客户端和服务器之间传输超文本数据&#xff08;比如文字、图片、音频、视频等&#xff09;的核心协议&#xff0c;当前互联网应用最广泛的版本是HTTP1.1&#xff0c;它基于经典的C/S模型&#xff0c;也就是客…...

编程新知 2025/12/10 6:18:55

Xen Server服务器释放磁盘空间

disk.sh #!/bin/bashcd /run/sr-mount/e54f0646-ae11-0457-b64f-eba4673b824c # 全部虚拟机物理磁盘文件存储 a$(ls -l | awk {print $NF} | cut -d. -f1) # 使用中的虚拟机物理磁盘文件 b$(xe vm-disk-list --multiple | grep uuid | awk {print $NF})printf "%s\n"…...

编程新知 2025/11/19 6:04:18

无人机侦测与反制技术的进展与应用

国家电网无人机侦测与反制技术的进展与应用 引言 随着无人机&#xff08;无人驾驶飞行器&#xff0c;UAV&#xff09;技术的快速发展&#xff0c;其在商业、娱乐和军事领域的广泛应用带来了新的安全挑战。特别是对于关键基础设施如电力系统&#xff0c;无人机的“黑飞”&…...

编程新知 2026/1/26 6:01:03

STM32---外部32.768K晶振（LSE）无法起振问题

晶振是否起振主要就检查两个1、晶振与MCU是否兼容&#xff1b;2、晶振的负载电容是否匹配 目录 一、判断晶振与MCU是否兼容 二、判断负载电容是否匹配 1. 晶振负载电容&#xff08;CL&#xff09;与匹配电容&#xff08;CL1、CL2&#xff09;的关系 2. 如何选择 CL1 和 CL…...

编程新知 2026/2/7 10:55:43