权重压缩
这是本人写的动态哈夫曼压缩算法实现，压缩与解压缩时，
根据文件内容自动生成哈夫曼树，并动态调整节点的权重
和树的形状。900MHZ的PIII赛扬每秒钟可以压缩的好几MB
的数据，只是压缩率不高，文本文件的压缩后容量一般可
以减少25%，比RAR差远了。
源文件共三个，你在VC6.0中新建一个空的命令行项目，
将它们加进去，编译完就可以用了。
===========hfm.cpp===================
#include <stdio.h>
#include <string.h>
#include <io.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "Huffman.h"
int wh;
int rh;
bool Write(unsigned char *s,int len){
_write(wh,s,len);
return true;
}
bool OpenFile(char* source,char* target){
int w_flag=_O_WRONLY | _O_CREAT | _O_EXCL | _O_BINARY;
int r_flag=_O_RDONLY | _O_BINARY;
rh=_open(source,r_flag,_S_IREAD | _S_IWRITE);
wh=_open(target,w_flag,_S_IREAD | _S_IWRITE);
if(rh==-1 || wh==-1){
if(rh!=-1){
_close(rh);
printf("\n打开文件：'%s'失败!",target);
}
if(wh!=-1){
_close(wh);
printf("\n打开文件：'%s'失败!",source);
}
return false;
}else{
return true;
}
}
void PrintUsage(){
printf("\n以动态哈夫曼算法压缩或解压缩文件。\n\n");
printf("\thfm -?\t\t\t\t显示帮助信息\n");
printf("\thfm -e -i source -o target\t压缩文件\n");
printf("\thfm -d -i source -o target\t解压缩文件\n\n");
}
void main(int argc,char *args[]){
int mode,i,j,K=0;
char src[4096];
char target[4096];
unsigned char buffer[BUFFER_SIZE];
Huffman *h;
mode=0;
for(i=1;i<argc;i++){
if(args[i][0]=='-' || args[i][0]=='/'){
switch(args[i][1]){
case '?':
mode=0;//帮助
break;
case 'e':
case 'E':
mode=1;//压缩
break;
case 'd':
case 'D':
mode=2;//解压缩
break;
case 'o':
case 'O':
if(i+1>=argc){
mode=0;
}else{//输出文件
j=0;
while(args[i+1][j]!='\0' && j<4096){
target[j++]=args[i+1][j];
}
if(j==4096){
mode=0;
}else{
target[j]='\0';
K |= 1;
}
}
break;
case 'i':
case 'I':
if(i+1>=argc){
mode=0;
}else{//输入文件
j=0;
while(args[i+1][j]!='\0' && j<4096){
src[j++]=args[i+1][j];
}
if(j==4096){
mode=0;
}else{
src[j]='\0';
K |=2;
}
}
break;
}
}
}
if(K!=3)mode=0;
switch(mode){
case 0:
PrintUsage();
return;
case 1://压缩
if(!OpenFile(src,target))return;
h=new Huffman(&Write,true);
i=BUFFER_SIZE;
while(i==BUFFER_SIZE){
i=_read(rh,buffer,BUFFER_SIZE);
h->Encode(buffer,i);
}
delete h;
_close(rh);
_close(wh);
printf("压缩完毕!");
break;
case 2://解压缩
if(!OpenFile(src,target))return;
h=new Huffman(&Write,false);
i=BUFFER_SIZE;
while(i==BUFFER_SIZE){
i=_read(rh,buffer,BUFFER_SIZE);
h->Decode(buffer,i);
}
delete h;
_close(rh);
_close(wh);
printf("解压缩完毕!");
break;
}
}
=======end of hfm.cpp=======================
=======Huffman.cpp=============================
// Huffman.cpp: implementation of the Huffman class.
//
//////////////////////////////////////////////////////////////////////
#include "Huffman.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
Huffman::Huffman(Output *output,bool mode)
{
Hbtree *tmp;
int i;
this->mode=mode;
//设置输出函数，当缓冲区满时，将调用该函数输出
this->output=output;
//初始化列表
for(i=0;i<LIST_LENGTH;i++)this->list[i]=NULL;
//初始化哈夫曼树
this->root=this->NewNode(NOT_CHAR,LEFT,NULL);
this->current=this->root;
tmp=this->NewNode(CODE_ESCAPE,RIGHT,root);
tmp->count=1;
tmp=this->NewNode(CODE_FINISH,LEFT,root);
tmp->count=0;
root->count=root->child[LEFT]->count+root->child[RIGHT]->count;
//设置缓冲区指针
this->char_top=BOTTOM_BIT;
this->bit_top=TOP_BIT;
this->buffer[0]=0;
//重构哈夫曼树的最大计数值
this->max_count=MAX_COUNT;
this->shrink_factor=SHRINK_FACTOR;
this->finished=false;
}
Huffman::~Huffman()
{
if(this->mode==true){//如果是编码
//输出结束码
this->OutputEncode(CODE_FINISH);
this->char_top++;
}
//强制清空缓冲区
this->Flush();
//释放空间
this->ReleaseNode(this->root);
}
Hbtree * Huffman::NewNode(int value, int index, Hbtree *parent)
{
Hbtree *tmp=new Hbtree;
tmp->parent=parent;
tmp->child[0]=NULL;
tmp->child[1]=NULL;
tmp->count=(1 << SHRINK_FACTOR);
tmp->index=(index==0) ? 0 : 1;
tmp->value=value;
if(value!=NOT_CHAR)this->list[tmp->value]=tmp;
if(parent!=NULL)parent->child[tmp->index]=tmp;
return tmp;
}
void Huffman::ReleaseNode(Hbtree *node)
{
if(node!=NULL){
this->ReleaseNode(node->child[LEFT]);
this->ReleaseNode(node->child[RIGHT]);
delete node;
}
}
//输出一位编码
int Huffman::OutputBit(int bit)
{
unsigned char candidates[]={1,2,4,8,16,32,64,128};
if(bit!=0)
this->buffer[this->char_top] |= candidates[this->bit_top];
this->bit_top--;
if(this->bit_top < BOTTOM_BIT){
this->bit_top=TOP_BIT;
this->char_top++;
if(this->char_top >= BUFFER_SIZE){//输出缓冲区
this->output(this->buffer,BUFFER_SIZE);
this->char_top=0;
}
this->buffer[this->char_top]=0;
}
return 0;
}
//输出缓冲区
int Huffman::Flush()
{
this->output(this->buffer,this->char_top);
this->char_top=0;
return 0;
}
int Huffman::Encode(unsigned char c)
{
int value=c,
candidates[]={128,64,32,16,8,4,2,1},
i;
if(this->list[value]==NULL){//字符不存在于哈夫曼树中
//输出转义码
this->OutputEncode(CODE_ESCAPE);
//输出字符
for(i=0;i<8;i++)this->OutputBit(value & candidates[i]);
this->InsertNewNode(value);
}else{
//输出字符编码
this->OutputEncode(value);
//重新调整哈夫曼树
this->BalanceNode(this->list[value]->parent);
}
//重组哈夫曼树
if(this->root->count>=this->max_count)
this->RearrangeTree();
return 0;
}
void Huffman::BalanceNode(Hbtree *node)
{
Hbtree *parent,*child,*brother;
int i,j;
parent=node->parent;
if(parent==NULL)return;//根节点无需调整
if(node->value==NOT_CHAR){//非叶子节点
child=node->child[LEFT]->count > node->child[RIGHT]->count ?
node->child[LEFT] : node->child[RIGHT];
if(child->count > parent->count - node->count){
//失衡
i=!(node->index);
j=child->index;
node->count=parent->count - child->count;
brother=parent->child[i];
node->child[j]=brother;
brother->index=j;
brother->parent=node;
parent->child[i]=child;
child->index=i;
child->parent=parent;
}
}
this->BalanceNode(parent);
}
//输出一个字符的编码
int Huffman::OutputEncode(int value)
{
int stack[CODE_FINISH+2],top=0;
Hbtree *tmp=this->list[value];
//输出编码
if(value<=MAX_VALUE){//字符
while(tmp!=NULL){
stack[top++]=tmp->index;
tmp->count++;
tmp=tmp->parent;
}
}else{//控制码
while(tmp!=NULL){
stack[top++]=tmp->index;
tmp=tmp->parent;
}
}
top--;
while(top>0){
this->OutputBit(stack[--top]);
}
return 0;
}
void Huffman::PrintNode(Hbtree *node,int level)
{
int i;
if(node){
for(i=0;i<level*3;i++)printf(" ");
printf("%p P:%p L:%p R:%p C:%d",node,node->parent,node->child[0],node->child[1],node->count);
if(node->value!=NOT_CHAR)printf(" V:%d",node->value);
printf("\n");
this->PrintNode(node->child[LEFT],level+1);
this->PrintNode(node->child[RIGHT],level+1);
}
}
int Huffman::Encode(unsigned char *s, int len)
{
int i;
for(i=0;i<len;i++)this->Encode(s[i]);
return 0;
}
void Huffman::PrintTree()
{
this->PrintNode(this->root,0);
}
int Huffman::RecountNode(Hbtree *node)
{
if(node->value!=NOT_CHAR)return node->count;
node->count=
this->RecountNode(node->child[LEFT]) +
this->RecountNode(node->child[RIGHT]);
return node->count;
}
void Huffman::RearrangeTree()
{
int i,j,k;
Hbtree *tmp,*tmp2;
//所有非控制码的计数值右移shrink_factor位，并删除计数值为零的节点
for(k=0;k<=MAX_VALUE;k++){
if(this->list[k]!=NULL){
tmp=this->list[k];
tmp->count >>= this->shrink_factor;
if(tmp->count ==0){
this->list[k]=NULL;
tmp2=tmp->parent;
i=tmp2->index;
j=!(tmp->index);
if(tmp2->parent!=NULL){
tmp2->parent->child[i]=tmp2->child[j];
tmp2->child[j]->parent=tmp2->parent;
tmp2->child[j]->index=i;
}else{
this->root=tmp2->child[j];
this->current=this->root;
this->root->parent=NULL;
}
delete tmp;
delete tmp2;
}
}
}
//重新计数
this->RecountNode(this->root);
//重新调整平衡
for(i=0;i<=MAX_VALUE;i++){
if(this->list[i]!=NULL)
this->BalanceNode(this->list[i]->parent);
}
}
void Huffman::InsertNewNode(int value)
{
int i;
Hbtree *tmp,*tmp2;
//将字符加入哈夫曼树
tmp2=this->list[CODE_FINISH];
tmp=this->NewNode(NOT_CHAR, tmp2->index, tmp2->parent);
tmp->child[LEFT]=tmp2;
tmp2->index=LEFT;
tmp2->parent=tmp;
tmp2=this->NewNode(value,RIGHT,tmp);
tmp->count=tmp->child[LEFT]->count+tmp->child[RIGHT]->count;
i=tmp2->count;
while((tmp=tmp->parent)!=NULL)tmp->count+=i;
//从底向上调整哈夫曼树
this->BalanceNode(tmp2->parent);
}
int Huffman::Decode(unsigned char c)
{
this->Decode(c,7);
return 0;
}
int Huffman::Decode(unsigned char *s,int len)
{
int i;
for(i=0;i<len;i++)this->Decode(s[i]);
return 0;
}
int Huffman::Decode(unsigned char c, int start)
{
int value=c,
candidates[]={1,2,4,8,16,32,64,128},
i,j;
Hbtree *tmp;
if(this->finished)return 0;
i=start;
if(this->current==NULL){//转义状态下
while(this->remain >= 0 && i>=0){
if((candidates[i] & value) !=0){
this->literal |= candidates[this->remain];
}
this->remain--;
i--;
}
if(this->remain < 0){//字符输出完毕
//输出字符
this->OutputChar(this->literal);
//将字符插入哈夫曼树
this->InsertNewNode(literal);
//重组哈夫曼树
if(this->root->count>=this->max_count)
this->RearrangeTree();
//设置环境
this->current=this->root;
}
}else{
j=((value & candidates[i])!=0)?1:0;
tmp=this->current->child[j];
i--;
while(tmp->value==NOT_CHAR && i>=0){
j=((value & candidates[i])!=0)?1:0;
tmp=tmp->child[j];
i--;
}
if(tmp->value==NOT_CHAR){//中间节点
this->current=tmp;
}else{
if(tmp->value<=MAX_VALUE){//编码内容
j=tmp->value;
this->OutputChar((unsigned char)j);
//修改计数器
tmp=this->list[j];
while(tmp!=NULL){
tmp->count++;
tmp=tmp->parent;
}
//调整平衡度
this->BalanceNode(this->list[j]->parent);
//重组哈夫曼树
if(this->root->count>=this->max_count)
this->RearrangeTree();
//设置环境
this->current=this->root;
}else{
if(tmp->value==CODE_ESCAPE){//转义码
this->current=NULL;
this->remain=7;
this->literal=0;
}else{//结束码
this->finished=true;
return 0;
}
}
}
}
if(i>=0)this->Decode(c,i);
return 0;
}
int Huffman::OutputChar(unsigned char c)
{
this->buffer[this->char_top++]=c;
if(this->char_top>=BUFFER_SIZE){//输出缓冲区
this->output(this->buffer,BUFFER_SIZE);
this->char_top=0;
}
return 0;
}
========end of Huffman.cpp==================
========Huffman.h============================
// Huffman.h: interface for the Huffman class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(NULL)
#include <stdio.h>
#endif
#if !defined(AFX_HUFFMAN_H__B1F1A5A6_FB57_49B2_BB67_6D1764CC04AB__INCLUDED_)
#define AFX_HUFFMAN_H__B1F1A5A6_FB57_49B2_BB67_6D1764CC04AB__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#define MAX_COUNT 65536 //最大计数值，大于此值时
#define MAX_VALUE 255 //编码的最大值
#define CODE_ESCAPE MAX_VALUE+1 //转义码
#define CODE_FINISH MAX_VALUE+2 //结束码
#define LIST_LENGTH MAX_VALUE+3 //编码列表长度
#define SHRINK_FACTOR 2 //减小的比例，通过右移位实现
#define LEFT 0 //左孩子索引
#define RIGHT 1 //右孩子索引
#define NOT_CHAR -1 //非字符
#define TOP_BIT 7 //字符最高位
#define BOTTOM_BIT 0 //字符最低位
#define BUFFER_SIZE 81920 //缓冲区大小
//输出函数
typedef bool (Output)(unsigned char *s,int len);
//哈夫曼树的节点定义
typedef struct Hnode{
int count;//计数器
int index;//父节点的孩子索引（0--左孩子，1--右孩子）
Hnode* child[2];
Hnode* parent;
int value;
}Hbtree;
class Huffman
{
private:
//输出一个解码的字符
int OutputChar(unsigned char c);
//从指定位置开始解码
int Decode(unsigned char c,int start);
//插入一个新节点
void InsertNewNode(int value);
//重新调整哈夫曼树构型
void RearrangeTree();
//对各节点重新计数
int RecountNode(Hbtree *node);
//打印哈夫曼树节点
void PrintNode(Hbtree *node,int level);
//输出一个值的编码
int OutputEncode(int value);
//调节哈夫曼树节点使之平衡
void BalanceNode(Hbtree *node);
//输出一位编码
int OutputBit(int bit);
//释放哈夫曼树节点
void ReleaseNode(Hbtree *node);
//新建一个节点
Hbtree *NewNode(int value,int index, Hbtree *parent);
//输出函数地址
Output *output;
//哈夫曼树根地址
Hbtree *root;
//哈夫曼编码单元列表
Hbtree *list[LIST_LENGTH];
//输出缓冲区
unsigned char buffer[BUFFER_SIZE];
//缓冲区顶
int char_top,bit_top;
//收缩哈夫曼树参数
int max_count,shrink_factor;
//工作模式，true--编码，false--解码
bool mode;
//解码的当前节点
Hbtree *current;
int remain;//当前字符剩余的位数
unsigned char literal;//按位输出的字符
bool finished;
public:
//解码指定长度的字符串
int Decode(unsigned char *s,int len);
//解码一个字符
int Decode(unsigned char c);
//打印哈夫曼树
void PrintTree();
//编码指定长度的字符串
int Encode(unsigned char *s,int len);
//编码一个字符
int Encode(unsigned char c);
//清空缓冲区
int Flush();
//output指输出函数，mode指工作模式，true--编码，false--解码
Huffman(Output *output,bool mode);
//析构函数
virtual ~Huffman();
};
#endif // !defined(AFX_HUFFMAN_H__B1F1A5A6_FB57_49B2_BB67_6D1764CC04AB__INCLUDED_)
================end of Huffman.h==================
祝你好运！
2. 抖音播放量怎么提升
怎样才能提升抖音播放量，可以从以下五个方面来考虑。
抖音播放量低的原因，怎么提升播放量？
一、视频清晰度不够
一般来说，视频清晰度不够是因为：
(1)视频拍摄模糊。
(2)视频导出不高清。视频尽量选择高清输出，一般选择1080P。
(3)平台压缩。由于本身视频清晰度不够，平台再进行压缩，则视频画面越发模糊。
二、账号权重低，官方不推荐
没有推荐，抖音播放量自然少。通过提高抖音账号权重，获得推荐量，提高抖音播放量。
如果视频播放量低于100,则属于僵尸号，播放量处于100-200之间的熟悉低权重号。
一般来说，僵尸号建议直接注销账号，注销后重新注册新号，然后通过养号提高账号初始权重。而低权重号，则需要发布高质量原创视频+养号来提高权重。
三、尽量原创，切勿搬运视频
视频原创度决定了抖音播放量，对于任何搬运的视频不仅没有推荐，而且还会降低该账号权重，严重的还有封号的风险。
四、账号频繁切换或异地登录
抖音养号第一条：一卡一机一号。如果频繁切换账号，或者经常异地登录，则给抖音官方的信号即该账号不稳定，会减少账号推荐，从而导致播放量减少。
五、频繁修改资料信息或大量删除作品
这也是涉及到账号稳定性的问题，频繁的修改账号，或者频繁的取消关注、删除作品都有可能被平台判定为账号不稳定。
以上原因，都可能导致作品播放量低，涨粉缓慢，各项数据停滞不前，就更谈不上变现了。针对以上问题，总结就是短视频拍摄制作+抖音养号提高权重的两个知识点。
3. PC和移动网站权重相差很大 从哪些方面去分析
1、移动端建站的域名选择
移动建站选择域名的标准与PC端网站相似，应尽量选择简单、容易记的域名，现在很多企业将手机站设计为二级域名，放在传统PC端网站的顶级域名之下，这也是大势所趋。
如果是单独为移动用户建设的网站，征帆网络建议你最好取一个简单易记的顶级域名。
2、移动端的网络速度
手机用户大多是通过2G、3G网络来上网，网络速度远低于大部分PC常用的有线网络，所以移动端网页如果过大，加载时间就会越长，会增加网民访问的跳出率。
对于移动端来说，所有的加载速度必须在1秒之内，这对网站加载速度就产生了要求，在此，征帆网络特意整理了6大主流的快速加载网站方式：
（1）、将文件压缩为Gzip格式。
（2）、用工具对图片无损压缩。
（3）、尽量避免无意义的网页重定向。
（4）、利用静态缓存。
（5）、异步脚本转为后台下载。
（6）、缩
4. 网站内部优化的一些可操作点
1、内容质量
既然注重网站的内容质量就一定要更新高质量的内容，当然，高质量的内容并不是说网站内容的原创度高就是高质量的内容，原创度只是高质量内容包含的一个因素，既然是高质量的内容首先我们要保证是原创的内容，其次还是注重网站的内容是否能满足用户的需求，对用户来说是否有价值，并且要增加内容的全面性以及内容的可读性，关于内容的可读性我们可以适当的增加内容的字数，也可以在内容中适当的添加一些图片来缓解用户阅读时的疲劳感，只有全方面提升内容的质量增加用户体验，才能算得上是高质量的内容。
2、关键词设置
对于网站的关键词设置不仅限于我们网站的首页，我们网站更新的文章以及我们网站的内页都可以设置关键词，有很多人总是忽略网站内页的关键词设置，其实在网站的内页上设置的关键词更加有利于网站的长尾关键词排名，因为搜索引擎蜘蛛不止会抓取你的网站首页同样也会抓取你的网站内页并且给予排名，而通过内页设置的关键词更加有利于网站长尾关键词的排名，当然，内页不止能设置关键词还能设置title以及页面的描述信息，这都是有利于页面的排名的，相对于一些大型的网站来说，每个SEO甚至多个SEP优化一个网站的页面，并不是整站来优化的，所以，我们在做网站的内部优化时一定不要忽略内页的优化。
3、友情链接
虽然网络算法的更新降低了外链的权重，但是并没有降低友情链接的权重，也就是说友情链接对我们网站的关键词排名还是有非常高的价值的，但是对于一些企业站来说，不止网站的首页可以交换友情链接，网站的内页同样也可以交换友情链接，但是通过网站内页交换的友情链接一定要保证我们的网站要比对方的网站权重高出一些，这样才会公平一些，因为我们是通过网站的内页交换对方网站首页的友情链接，相对来说对方网站的权重以及引流的效果都会比我们的网站好很多，这种情况下我们只能交换比自身权重低一些的网站的友情链接。
4、控制跳出率
通常很多人都忽略了网站的跳出率这项数据，网站的跳出率往往对网站的排名也有很大的影响，如果网站的跳出率很高就证明网站的内容并没有价值，这个时候就应该适当的增加网站的用户体验来增加用户粘度，降低用户的跳出率，如果网站的跳出率不是很高就不用做太大的修改，继续保持优化的措施就可以了。
5、内部链接
网站的内部链接这个问题我在之前的文章中有像大家简单的介绍过，对于网站的内部链接并不是越少越好，只要我们能让网站的内部链接保持清晰，对于蜘蛛来说，蜘蛛在抓取你的网站时不会出现进入某个页面没有回到首页的链接这种情况发生就可以，对于用户来说，用户想要寻找你网站的某个内容，能让用户在最短的时间之内找到用户最需要的内容，降低用户的时间成本，就是最好的内部链接。
6、代码优化
代码优化的这篇文章昨天就详细的交给大家了，代码优化对于网站的站内优化有很大的影响，比如网站的H标签以及网站的title和关键词等都是网站代码优化中一定要做的优化措施，为网站设置一个利于优化的标题会有助于关键词排名，同样在标题中也一定要出现网站设定的主关键词，并且在描述信息中适当的出现网站的关键词都会有利于网站的关键词排名，有很多人认为网站的标题中的关键词对设定的关键词排名并没有多大影响，其实这样是不对的，如果你在搜索引擎中搜索某个关键词，你会发现大部分网站的标题以及描述信息中都存在这个关键词，增加网站主关键词的匹配度。
7、网站运行速度优化
根据调查显示，有一部分的用户在打开某个网站时，如果这个网站超过三秒钟还没有打开，那么这个用户索性就会点击右上角的关闭，因为在这些用户的眼中，一个正规的网站打开速度一定会很快，并且如果网站的打开速度过慢会影响用户在浏览我们网站时的心情，增加用户的时间成本，降低网站的用户体验，所以，我们在为网站做优化时，一定要做好网站速度上的优化措施。
8、网站路径优化
我们都知道一个网站的路径有很多，并且越是网站的内页它的路径就会越深，当然，对于搜索引擎来说，路径越浅越容易被搜索引擎收录，路径浅的页面相对来说会重要一些，比如我们网站的首页就相当于网站的根目录，所以在搜索引擎眼中，网站的首页也是最重要的，所以会给予网站首页额外的权重，当然这种情况也可以用扁平化的布局方式来解决。