1.?左长左长󳤺??ҳ???Ԥ??Դ??
2.10.怎么玩转单片机双灯左移右移闪烁
3.求精神异常梦游症患者调查报告，天才在左疯子在右资源

?黑右黑右󳤺??ҳ???Ԥ??Դ??

       哈弗曼压缩

       #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();//不加此句，关闭程序再解压，左长左长小说小程序源码会提示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,黑右黑右先算源码还是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

       }

.怎么玩转单片机双灯左移右移闪烁

       .怎么玩转单片机双灯左移右移闪烁

       手把手教会你单片机编程

       单片机智能控制，单片机源代码

       /*----------------------------------------------- 名称：IO口高低电平控制 修改：无 内容：2个led灯先左移，长红长红然后右移，预警源码然后同时闪烁 ------------------------------------------------*/

       #includereg.h //包含头文件，选股一般情况不需要改动， //头文件包含特殊功能寄存器的定义 void Delay(unsigned int t); //函数声明 /*------------------------------------------------ 主函数 ------------------------------------------------*/ void main (void) { unsigned char i; //定义一个无符号字符型局部变量 i //取值范围 0~ unsigned char temp;//定义临时变量用于转换 while (1)     //主循环 { temp=0xfc; P1=temp; for(i=0;i7;i++)  //加入 for循环，表明for循环大括号 //中的程序循环执行7次 { Delay();   //调用延时程序；更改延时数字可 //以更改延时长度；用于改变闪烁频率 temp=1; temp=temp|0x;  //也可以直接把temp换成P1 P1=temp;      //之所以加入temp做中间变量，转换 //完成后直接赋值到端口，防止直接 //操作端口造成的短暂闪烁 } temp=0x3f; P1=temp; for(i=0;i7;i++)  //加入 for循环，表明for循环大括号 //中的程序循环执行7次 { Delay();   //调用延时程序；更改延时数字可以 //更改延时长度；用于改变闪烁频率 temp=1; temp|=0x;    //等效于 temp=temp|0x P1=temp; } for(i=0;i3;i++)  //加入 for循环，表明for循环大括号 //中的程序循环执行3次 { P1=0xff; Delay(); P1=0x; Delay(); }        //主循环中添加其他需要一直工作的程序 } } /*------------------------------------------------ 延时函数，含有输入参数 unsigned int t，写字楼源码无返回值 unsigned int 是定义无符号整形变量，其值的范围是 0~ ------------------------------------------------*/ void Delay(unsigned int t) { while(--t); }

求精神异常梦游症患者调查报告，天才在左疯子在右资源

       如果用比喻来解释，可以将人脑比作电脑，其中硬件是脑部结构，软件则是神经系统，它支持并实现脑部功能，就像源代码一样。而后天习得的技能，就像是安装在脑中的应用程序。就像电脑有不同配置一样，淘源码站人脑也因遗传差异而有不同的能力水平。一台电脑通常可以安装两到三个操作系统，包括一个备份系统，它们可以是独立或互相备份的。人脑自带两套系统，一套是日常使用的，另一套是备份系统，还有些人会有第三套系统。就像电脑在使用过程中会积累和优化信息一样，人脑在成长过程中也会学习和掌握新技能。

       以Windows 7操作系统为例，友价游戏源码当安装这个系统时，通常会有一键还原功能来备份原始系统。如果日常系统出现问题，可以重新引导至初始系统。大多数人的神经系统相对稳定，不会轻易激活备份系统。因此，梦游行为通常只影响少数人。备份系统处于初始状态，所以在梦游时可能会进行家务或切菜，但动作可能不流畅，也不会说出完整的句子。尽管如此，基本功能通常还是 intact，比如不会撞到障碍物或切伤自己（这是非常神奇的地方）。两套系统是独立的，所以在使用初始系统时所做的所有事情，都不会被记录在常用系统中。因此，第二天醒来后，梦游的经历通常会被完全忘记。可以说，备份系统是常用系统的一个隐性的应急系统。

       当精神压力过大时，可能导致入睡后常用系统仍然活跃而出现崩溃，这时备份系统会被启动。例如，精神压力大的人更有可能出现梦游。梦游通常发生在入睡后，完全不清醒的情况下。就像电脑可以安装与Windows 7共存的不同系统，如Windows 8或Linux、Unix等，人脑也有可能发展出第三套神经系统。例如，有些人可以有灵魂出窍或濒死体验的经历，他们的肉体完全静止，这超出了梦游的范畴。灵魂出窍的人会看到正在发生或他们想象的事情，并在回到体内后仍然记得这些经历。这说明第三套系统完全不同于常用系统下的备份系统，并且与常用系统有良好的兼容性，记忆信息可以互相交换。然而，对大多数人来说，第三套系统是不存在的。但通过后天学习或经历极大的痛苦，有可能获得并体验这一系统。例如，有些方士、道士报告的灵魂出窍现象，或者在极端情况下，如年汶川地震中，陈坚在等待救援时，尽管身体不动，但摄像机捕捉到了他漂浮的“灵魂”。