皮皮网

1.SDS是什么
2.求VC++源代码，200行左右，要有详细注释，悬赏！！！源码asp订单
3.Redis底层数据结构解密？

SDS是什么

       目前国内软件定义存储产品主要分两类：

       自主研发，比如 SmartX，华为；

       基于开源的 Ceph 研发，比如 XSKY，杉岩，cef c 源码深信服。

求VC++源代码，行左右，要有详细注释，悬赏！！相册集 源码！

       哈弗曼压缩

       #include <string.h>

       #include <stdlib.h>

       #include<iostream.h>

       #include<fstream.h>

       #define MaxNodes

       #define MaxBufSize

       #define MaxBits

       struct Node

       {

        unsigned char b;

        int count;

        int parent,lch,rch;

        char bits[MaxBits];

       }Nodes[MaxNodes];

       ifstream ifile;

       ofstream ofile;

       char *fname=new char();

       unsigned char c;

       char buf[MaxBufSize];

       int flen;

       int NodesNum;

       void decompress();

       void compress();

       void charCount();

       void initNodes();

       void creatHuffTree();

       void huffCoding();

       void sortByCount();

       int FindMin(int curlen);

       void comToFile();

       void decomToFile();

       void clearSDS();

       void locChar(int loc,int i);

       void main()

       {

        char choice;

        while(1)

        {

        cout<<" ------------------------------------------------------"<<endl;

        cout<<" # 0.退出 #"<<endl;

        cout<<" # 1.压缩 #"<<endl;

        cout<<" # 2.解压 #"<<endl;

        cout<<" ------------------------------------------------------"<<endl;

        do

        {

        cout<<"请选择："<<endl;

        cin>>choice;

        if(choice!='0' && choice!='1' && choice!='2')

        {

        cout<<"输入出错！请重新输入！"<<endl;

        }

        }

        while(choice!='0' && choice!='1' && choice!='2');

        switch(choice)

        {

        case '0':cout<<"成功退出！"<<endl;exit(0); break;

        case '1':compress();break;

        case '2':decompress();break;

        }

        }

       }

       void compress()

       {

        cout<<"请输入待压缩的文件名：";

        cin>>fname;

        ifile.open(fname,ios::nocreate|ios::binary);

        if(!ifile)

        {

        cout<<"文件不存在!"<<endl;

        return;

        }

        charCount();

        initNodes();

        sortByCount();

        creatHuffTree();

        huffCoding();

        cout<<"请输入压缩后的文件名：";

        cin>>fname;

        ofile.open(fname,ios::binary);

        ofile.write((char*)&NodesNum,sizeof(NodesNum));

        ofile.write((char*)&flen,sizeof(flen));

        for(int i=0;i<NodesNum;i++)

        {

        ofile.write((char*)&Nodes[i].b,sizeof(Nodes[i].b));

        ofile.write((char*)&Nodes[i].count,sizeof(Nodes[i].count));

        }

        comToFile();

        ifile.close();

        ofile.close();

        clearSDS();

       }

       void decompress()

       {

        clearSDS();//不加此句，关闭程序再解压，html下雨源码会提示BUF出错

        cout<<"请输入待解压的文件名：";

        cin>>fname;

        ifile.open(fname,ios::nocreate|ios::binary);

        if(!ifile)

        {

        cout<<"文件不存在!"<<endl;

        return;

        }

        ifile.read((char*)&NodesNum,sizeof(NodesNum));

        ifile.read((char*)&flen,sizeof(flen));

        cout<<NodesNum<<" "<<flen<<endl;

        for(int i=0;i<NodesNum;i++)

        {

        ifile.read((char*)&Nodes[i].b,sizeof(Nodes[i].b));

        ifile.read((char*)&Nodes[i].count,sizeof(Nodes[i].count));

        }

        creatHuffTree();

        cout<<"请输入解压后的文件名：";

        cin>>fname;

        ofile.open(fname);

        decomToFile();

        ifile.close();

        ofile.close();

        clearSDS();

       }

       void clearSDS()//SDS is short for Shared Data Structure

       {

        NodesNum=flen=c=0;

        for(int i=0;i<MaxNodes;i++)

        {

        Nodes[i].b=0;

        Nodes[i].count=0;

        Nodes[i].parent=Nodes[i].lch=Nodes[i].rch=-1;

        buf[i]=0;

        for(int j=0;j<MaxBits;j++) Nodes[i].bits[j]=0;

        }

       }

       void comToFile()

       {

        ifile.clear();

        ifile.seekg(0);

        char tbuf[]="";

        while(ifile.get(c))

        {

        for(int i=0;i<NodesNum;i++)

        {

        if(c==Nodes[i].b)

        {

        strcat(buf,Nodes[i].bits);

        break;

        }

        }

        while(strlen(buf)>=8)

        {

        memcpy(tbuf,buf,8);

        c=(char)strtol (tbuf,NULL,2);

        memmove(buf,buf+8,strlen(buf)+1-8);

        ofile.write((char*)&c,sizeof(c));

        }

        }

        if(strlen(buf)>0)//剩余

        {

        strcat(buf,"");//最多接7个0即可

        memcpy(tbuf,buf,8);

        c=(char)strtol (tbuf,NULL,2);

        ofile.write((char*)&c,sizeof(c));

        }

       }

       void decomToFile()

       {

        while (ifile.get(c)) //while(!ifile.eof()),老样子

        { //ifile.read((char*)&c,sizeof(c));

        char tbuf[]="";

        char rbuf[]="";

        itoa((int)c,rbuf,2);

        strcpy(tbuf+8-strlen(rbuf),rbuf);

        memmove(buf+strlen(buf),tbuf,8);//末尾会多一个tbuf，无碍

        while(strlen(buf)>&&flen>0) locChar(2*NodesNum-2,0);

        }

        while(strlen(buf)>0&&flen>0) locChar(2*NodesNum-2,0);

       }

       void locChar(int loc,int i)//递归得出字符

       {

        if((Nodes[loc].lch==-1)&&(Nodes[loc].rch==-1))

        {

        ofile.write((char*)&Nodes[loc].b,sizeof(Nodes[loc].b));

        flen--;

        //memmove(buf,buf+i,strlen(buf)-i+1);

        //memmove(buf,buf+i,-i);//Very improtant code modified at here!

        memcpy(buf,buf+i,-i);//Same result Like the line Above!Maybe not effective

        return;

        }

        else

        {

        switch( buf[i])

        {

        case '0': loc=Nodes[loc].lch;break;

        case '1': loc=Nodes[loc].rch;break;

        default: cout<<"buf中出错！"<<endl;break;

        }

        i++;

        locChar(loc,i);

        }

       }

       void charCount()//统计字符出现次数

       {

        while(ifile.get(c))

        {

        Nodes[c].count++;

        flen++;//得出文件长度

        }

       }

       void initNodes()//初始化

       {

        for(int i=0;i<MaxNodes;i++)

        {

        if(Nodes[i].count!=0)

        Nodes[i].b=(unsigned char)i;

        else Nodes[i].b=0;

        Nodes[i].parent=Nodes[i].lch=Nodes[i].rch=-1;

        }

       }

       void creatHuffTree()//建树

       {

        int t=2*NodesNum-1;

        for(int i=NodesNum;i<t;i++)

        {

        int loc=FindMin(i);

        Nodes[i].count=Nodes[loc].count;

        Nodes[loc].parent=i;

        Nodes[i].lch=loc;

        loc=FindMin(i);

        Nodes[i].count+=Nodes[loc].count;

        Nodes[loc].parent=i;

        Nodes[i].rch=loc;

        }

        Nodes[t-1].parent=-1;

       }

       int FindMin(int curlen)//找没有父结点，且Count最小的节点

       {

        int loc=curlen-1;//找不到，返回最后一个，最后一个不在查找范围

        for(int i=0;i<curlen;i++)

        {

        if(Nodes[i].count<=Nodes[loc].count)

        {

        if(Nodes[i].parent==-1)

        loc=i;

        }

        }

        return loc;

       }

       void huffCoding()//根据树来编码

       {

        int Pid,thinksns 活动 源码t;//Parent id

        for(int i=0;i<NodesNum;i++)

        {

        t=i;

        while(Nodes[t].parent!=-1)

        {

        Pid=Nodes[t].parent;

        if(Nodes[Pid].lch==t) //置左分支编码0

        { //函数原型：void *memmove( void *dest, const void *src, size_t count );

        memmove(Nodes[i].bits+1,Nodes[i].bits,strlen(Nodes[i].bits)+1);

        Nodes[i].bits[0]='0';

        }

        else //置右分支编码1

        {

        memmove(Nodes[i].bits+1,Nodes[i].bits,strlen(Nodes[i].bits)+1);

        Nodes[i].bits[0]='1';

        }

        t=Pid;

        }

        }

       }

       //降序

       void sortByCount()

       {

        Node tempNode;

        for(int i=0;i<MaxNodes;i++)

        for(int j=MaxNodes-1;j>i;j--)

        {

        if(Nodes[i].count<Nodes[j].count)

        {

        tempNode=Nodes[i];

        Nodes[i]=Nodes[j];

        Nodes[j]=tempNode;

        }

        }

        for(i=0;i<MaxNodes;i++) if(Nodes[i].count==0) break;

        NodesNum=i;//关键得出有效叶子结点个数NodesNum

       }

Redis底层数据结构解密？

       一：摘要概述

       很多 redis 的使用者都可以清晰明白的道出Redis中常用的对象如string、list、hash、set、zset,一些场景比较丰富的使用者可能会说布隆过滤器、geo、Hash等。但是对于这些对象底层实现的数据结构却是知之甚少,将会详细阐述redis中的底层数据结构。为了弥补大家的创伤，今天分享Redis底层数据结构内容。

       二：SDS

       string作为redis中常用对象之一,普遍用于用户信息缓存等场景。当string对象中encoding编码为embstr或raw时都是采用sds作为其底层实现

       2.1 SDS结构

       源码文件位于redis安装目录src下的sds.h,sds声明了五种头部类型,分别为sdshdr5、sdshdr8、sdshdr、sdshdr、sdshdr。根据字符串长度创建不同头部的sds实例

       struct __attribute__ ((__packed__)) sdshdr8 {

       uint8_t len;

       uint8_t alloc;

       unsigned char flags;

       char buf[];

       };

       属性名称作用含义

       len字符串长度

       alloc预分配空间大小

       flags低三位用于表示sds类型,可以查看sds.h文件-行定义

       buf[]存储字符串用数组

       2.2 SDS与C字符串区别

       区别描述

       长度计算 c中的字符串长度计算需要数组遍历,但是redis中的sds自身维护了len属性。所以O(1)时间复杂度即可

       缓冲区溢出c中字符串更改如果未提前做好内存分配则会内存溢出,但是sds则会根据alloc与len计算预留内存是否足够分配重新申请内存

       动态扩展 缓冲区溢出已经阐述这个概念,sds的内存空间会在字符串内容变更时自动扩展计算。策略为当字符换小于1M时*2翻倍,大于1M时每次扩容1M

       惰性释放 与空间预分配相似操作的还有内存惰性释放,即字符串删除某些内容后所占用的内存空间并不会立即释放,后续字符串变更扩展就无需再申请内存

       二：ZipList

       ziplist可以说把redis对于内存的极致操作体现的淋漓尽致,链表除了节点值之外还需要维护前后节点两个指针,并且还会造成内存碎片。压缩列表紧凑的内存布局,所有节点都维护在整块内存中处理

       2.1 ZipList结构

       属性名称作用含义

       zlbytes列表健占用内存的总字节数,在对列表健内存重分配或者是计算zlend的时候使用

       zltail 指向压缩列表起始地址的指针

       zllen 压缩列表的节点数量

       entry压缩列表保存的节点数据

       zlend压缩列表的尾节点

       2.2 Entry节点结构

       属性名称作用含义

       previous_entry_length 字节为单位记录上一个节点的长度,如果上一个字节长度小于占用1字节。大于占用5字节,第一个字节设置为OxFE(十进制),后面四个字节储存长度

       encoding 记录content记录的数据类型以及长度。长度一、二、五字节,值的最高位为、、表示类型为字节数组,长度使用除去最高位的其它位记录。开头表示储存整数,除去最高位其他位置表示content数据长度

       content 记录压缩列表记录的数据