權重壓縮
這是本人寫的動態哈夫曼壓縮演算法實現，壓縮與解壓縮時，
根據文件內容自動生成哈夫曼樹，並動態調整節點的權重
和樹的形狀。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、網站路徑優化
我們都知道一個網站的路徑有很多，並且越是網站的內頁它的路徑就會越深，當然，對於搜索引擎來說，路徑越淺越容易被搜索引擎收錄，路徑淺的頁面相對來說會重要一些，比如我們網站的首頁就相當於網站的根目錄，所以在搜索引擎眼中，網站的首頁也是最重要的，所以會給予網站首頁額外的權重，當然這種情況也可以用扁平化的布局方式來解決。