c语言-自己写的库

一.俗话说算法是程序的灵魂,这下面本人写了一部分常用算法,欢迎大家使用,并提出批评和指正,当然也可以改进或者添加。

1.这是自己实现的算法库头文件

#ifndef _INC_ALGORITHM
#define _INC_ALGORITHM
#endif

#include
#include
#include
#include
#include
#include

/*
本算法库封装了大多数常用算法,一部分摘取书籍,大部分为自己动手编写,
大部分经过测试,可以直接使用,如有错误,欢迎指正,使用请尊重作者的成果,注明出处。
注意:除了windows操作算法,其他都是跨平台的,本算法库在windows 8.1的VS2013上测试通过
学校:长安大学
作者:惠鹏博
时间:2017/5/25

算法包括:
1.排序类算法
2.数学类算法
3.逻辑类算法
4.Windosw操作算法
5.字符串算法
6.经典算法
7.数据结构算法
8.文件操作算法
*/



/********************************************排序类算法********************************************/
/*二分查找法,上,中,下,前提数组必须有序找到返回0否则返回-1*/
int binerySearch(char **p, int count, char *des);











/********************************************数学类算法********************************************/
/*乘法表打印方形*/
void print9X9Table();
/*乘法表打印反对角线以下*/
void print9X9Table1();
/*乘法表打印反对角线以上*/
void print9X9Table2();
/*乘法表打印正对角线以上*/
void print9X9Table3();
/*乘法表打印反对角线以下*/
void print9X9Table4();
/*乘法表打印反对角线上的*/
void print9X9Table5();
/*乘法表打印正对角线上的*/
void print9X9Table6();
/*乘法表打印两条对角线上部的*/
void print9X9TableUp();
/*乘法表打印两条对角线下部的*/
void print9X9TableDown();
/*乘法表打印两条对角线左边的*/
void print9X9TableLeft();
/*乘法表打印两条对角线右边的的*/
void print9X9TableRight();
/*求2的N次方*/
int T2n(int N);
/*求2的一次方到2的N次方的和*/
int S2n(int N);
/*求两个数的最大公因数 a > b*/
int maxCommonFactor(int a, int b);
/*求两个数的最小公倍数*/
int minCommonDouble(int a, int b);
/*获取N以下的质数,并按从小到大的顺序存放到数组P中,L为L为存放质数个数地址*/
void getPrimeNumTable(int N, int *P, int *L);
/*求一个数的所有质因数,并按从小到大的顺序存放到数组P中,L为存放质因数个数地址,F为中间获取质数的数组表,T为存储质数数组长度的变量*/
int getFactor(int m, int *P, int *F, int *L, int *T);
/*使用递归10进制转0进制打印*/
void  PrintBin(int n);
/*二进制整数转十进制,接受一个二进制字符串,将它转为10进制整数数*/
int BinToDec(char *bin);
/*十进制整数转二进制字符串*/
char *DecToBin(int num, char *s);
/*求一个数对另一个数的余数,不使用求模运算符*/
int YuNum(int a, int b);
/*求一个整数的翻转*/
int ReverseInt(int num);
/*取出一个整数的每个位,存入到一个数组中,第一个为个位,依次类推*/
int GetIntBit(int num, int bit[]);
/*产生一个N之内的随机数*/
int  RandomNumber(int N);
/*判断一个n位数num是不是水仙花数,每一位的数字由低到高存入bit数组中*/
int searchNumber(int num, int n, int bit[]);
/*生成n个小于m的随机数,并将生成的随机数存放到数组p中*/
void randNumber(int *p, int n, int m);






/********************************************逻辑问题类算法****************************************/
/************************四字节操作,如int ,long等类型**********************/

/*置位int数num的第N个位*/
void setInt(int *num, int N);
/*清零int数num的第N个位*/
void clearInt(int *num, int N);
/*统计num中是1的位数,返回位数*/
int statIntOne(int num);
/*统计num中是0的位数,返回位数*/
int statIntZero(int num);
/*翻转一个int数,即高位和低位互换 0位和31位互换,1位和30维护换返回位数*/
int reverseInt(int *num);
/*以二进制形式打印一个整数*/
void printfIntBinary(int num);
/*循环左移位的实现num左移N位*/
int moveToLeft(int num, int N);
/*循环右移位的实现num右移N位*/
int moveToRight(int num, int N);
/*使用位运算异或实现两个变量值的交换*/
void exchange(int *a, int *b);
/*获取int数num的第N个位的值,0或1*/
int getIntBit(int num, int N);
/*打印一个int数在内存中的二进制码*/
void printfBinCode(int num);
/*输出一个int数的原码,正数就是它的二进制码,负数就是对应二进制码(反码)的原码*/
void printfSrcCode(int num);
/*打印一个unsigned char 类型的二进制码*/
void printfCharCode(unsigned char s);
/*打印一个浮点数的二进制码*/
void printfFloatCode(float f);






/*********************************************Windows操作算法******************************************/
/*模拟鼠标单击*/
void SingleClick();
/*模拟鼠标双击*/
void DoubleClick();
/*模拟鼠标右击*/
void RightClick();
/*Left mouse button键的模拟*/
void LeftMouseButton();
/*Right mouse button键的模拟*/
void RightMouseButton();
/*Control-break processing键的模拟*/
void Cancle();
/*鼠标中键的模拟*/
void MiddleButton();
/*backspace键的模拟*/
void Backspace();
/*TAB key键的模拟*/
void Tab();
/*CLEAR key键的模拟*/
void ClearKey();
/*ENTER回车键 key键的模拟*/
void Enter();
/*SHIFT key键的模拟*/
void Shift();
/*CTRL key键的模拟*/
void Ctrl();
/*ALT key键的模拟*/
void Alt();
/*PAUSE key键的模拟*/
void Pause();
/*CAPS LOCK key键的模拟*/
void CapsLock();
/*ESC key键的模拟*/
void Esc();
/*SPACE空格 key键的模拟*/
void Space();
/*PAGE UP key键的模拟*/
void PageUp();
/*PAGE DOWN key键的模拟*/
void PageDown();
/*END key键的模拟*/
void End();
/*Home key键的模拟*/
void Home();
/*LEFT ARROW key键的模拟*/
void LeftArrow();
/*RIGHT ARROW key键的模拟*/
void RightArrow();
/*UP ARROW key键的模拟*/
void UpArrow();
/*DOWN ARROW key键的模拟*/
void DownArrow();
/*SELECT key键的模拟*/
void Select();
/*EXECUTE key键的模拟*/
void Execute();
/*PRINT SCREEN key键的模拟*/
void PrintScreen();
/*INSERT key键的模拟*/
void Insert();
/*DELETE key键的模拟*/
void Delete();
/*HELP key键的模拟*/
void Help();
/*Left Windows key键的模拟*/
void LeftWin();
/*Right Windows key键的模拟*/
void RightWin();
/*0 key键的模拟*/
void NumberThero();
/*1 key键的模拟*/
void NumberOne();
/*2 key键的模拟*/
void NumberTwo();
/*3 key键的模拟*/
void NumberThree();
/*4 key键的模拟*/
void NumberFour();
/*5 key键的模拟*/
void NumberFive();
/*6 key键的模拟*/
void NumberSix();
/*7 key键的模拟*/
void NumberSeven();
/*8 key键的模拟*/
void NumberEight();
/*9 key键的模拟*/
void NumbeNine();
/*乘号 key键的模拟*/
void Multiply();
/*加号 key键的模拟*/
void Add();
/*减号 Subtractkey键的模拟*/
void Subtract();
/*除号 /键的模拟*/
void Divide();
/*Separator 分隔符 \ 键的模拟*/
void Separator();
/*F1键的模拟*/
void F1();
/*F2键的模拟*/
void F2();
/*F3键的模拟*/
void F3();
/*F4键的模拟*/
void F4();
/*F5键的模拟*/
void F5();
/*F6键的模拟*/
void F6();
/*F7键的模拟*/
void F7();
/*F8键的模拟*/
void F8();
/*F9键的模拟*/
void F9();
/*F10键的模拟*/
void F10();
/*F11键的模拟*/
void F11();
/*F12键的模拟*/
void F12();
/*F13键的模拟*/
void F13();
/*F14键的模拟*/
void F14();
/*F15键的模拟*/
void F15();
/*F16键的模拟*/
void F16();
/*NUM LOCK键的模拟*/
void NumLock();
/* ";:" 键的模拟*/
void ColonAndSemicolon();
/* "+ =" 键的模拟*/
void PlusEquals();
/* "," 键的模拟*/
void Comma();
/* "- _" 键的模拟*/
void MinusHyphen();
/* "." 键的模拟*/
void Point();
/* "/ ?" 键的模拟*/
void Question();
/* "` ~" 键的模拟*/
void BoLangHao();
/* "[ {" 键的模拟*/
void LeftBrackets();
/* "\ |" 键的模拟*/
void VerticalLine();
/* "] }" 键的模拟*/
void RightBrackets();
/* "' "" 键的模拟*/
void YinHao();
/*win键的模拟*/
void win();
/*win+d键的组合模拟*/
void winAndD();
/*win+E键的组合模拟*/
void winAndE();
/*win+M键的组合模拟*/
void winAndM();
/*CTRL+ALT+DEL键的组合模拟*/
void ctrlAndAltAndDel();
/****************z26个字母键模拟*************************/
/*A键模拟*/
void AKey();
/*B键模拟*/
void BKey();
/*C键模拟*/
void CKey();
/*D键模拟*/
void DKey();
/*E键模拟*/
void EKey();
/*F键模拟*/
void FKey();
/*G键模拟*/
void GKey();
/*H键模拟*/
void HKey();
/*I键模拟*/
void IKey();
/*J键模拟*/
void JKey();
/*K键模拟*/
void KKey();
/*L键模拟*/
void LKey();
/*M键模拟*/
void MKey();
/*N键模拟*/
void NKey();
/*O键模拟*/
void OKey();
/*P键模拟*/
void PKey();
/*Q键模拟*/
void QKey();
/*R键模拟*/
void RKey();
/*S键模拟*/
void SKey();
/*T键模拟*/
void TKey();
/*U键模拟*/
void UKey();
/*V键模拟*/
void VKey();
/*W键模拟*/
void WKey();
/*X键模拟*/
void XKey();
/*Y键模拟*/
void YKey();
/*Z键模拟*/
void ZKey();


/*********************************************字符串算法*********************************************/
/*自己实现的字符串检索函数,s2为要检索的字符串,s1位源字符串*/
int strInStrPos(char s1[], char s2[]);
/*打印hello的8种方式打印八个hello*/
void printHello();
/*从一个字符串str中子串substr的前面增加一个新字符串newstr*/
void addStringInString(char *newstr, char *substr, char *str);
/*从一个字符串str中使用newstr替换一个子串substr*/
void changeStringInString(char *newstr, char *substr, char *str);
/*从一个字符串str中删除一个子串substr*/
void deleteStringInString(char *substr, char *str);














/**********************************************经典算法**********************************************/
/*河内之塔算法,N为盘子个数,A,B,C分别表示三个柱子,搬运次数*/
void Hanoi(int N, char A, char B, char C);

/*费氏数列:1 1 2 3 5 8 13 ......
有关系F(N) = F(N-1) + F(N-2)
求F(N)*/
int Fib(int N);

/*帕斯卡三角形,N为多项式的(a+b)^N中的N,n为系数所处的位置,返回值为系数值,要满足 N >= n*/
int Paska(int N, int n);
/*老鼠走迷宫问题:
使用二维阵列表示迷宫
用2表示墙壁,用0表示空白可以行走,用1表示老鼠可以走出的路径
在起始位置有四个方向可以走,上下左右,起始位置肯定空白
*/
#define M  10    //数组列数
//int flag = 0;    //是否找到标记
/*查看i行j列处是否为空白,返回1表示成功找到,返回0表示没有找到,*/
int visitArray(int startY, int startX, int endY, int endX, int(*P)[M]);

/*50个台阶,每次要么走一步,要么走两步,问有多少次走法
1个台阶     1                     1
2            11 2                 2
3            111 12 21             3
4            1111 22 121 112 211  5

要到达50,从48走2,或从49走1所以有F(N) = F(N-1) + F(N-2)
*/
int stepF(int n);











/*********************************************数据结构算法*********************************************/


















/*********************************************文件操作算法*********************************************/
/*从键盘读取字符输出到磁盘文件中,若读取到#,则结束*/
void readFromKey();
/*从磁盘文件读取内容,然后显示在屏幕上*/
void printFileContent();
/*文件复制*/
int copyFile(char *src, char *des);
/*将一个长度为L的整形数组a写入到路径path表示的文件中,flag为1表示在文件末尾追加,为0表示从文件头重新写入*/
void writeIntArrayToFile(int a[], int L, char *path, int flag);
/*将路径path表示的文件内容读取到整形数组a中,读取长度为L*/
void readFileToIntArray(int a[], int L, char *path);
/*将一个长度为L的Double数组a写入到路径path表示的文件中,flag为1表示在文件末尾追加,为0表示从文件头重新写入*/
void writeDoubleArrayToFile(double a[], int L, char *path, int flag);
/*将路径path表示的文件内容读取到双精度浮点数组a中,读取长度为L*/
void readFileToDoubleArray(double a[], int L, char *path);
/*将首地址为P的大小为L*SIZE的内存块写入到路径path表示的文件中,内存块的组成小块大小为SIZE,个数为L,flag为1表示在文件末尾追加,为0表示从文件头重新写入*/
void writeMemoryToFile(void *addr, int SIZE, int L, char *path, int flag);
/*将路径path表示的文件内容读取到首地址为P的大小为L*SIZE的内存块中,读取长度为L,每小块大小为SIZE字节*/
void readFileToMemory(void *addr, int SIZE, int L, char *path);
/*在黑窗口查看一个文本文件内容,使用cmd命令,path为文件路径*/
void lookFileUseType(char *path);
/*在黑窗口查看一个文本文件内容,使用文件指针,path为文件路径*/
void lookFileUsePointer(char *path);
/*测量一个文件长度,查看文件大小,字节数表示,返回-1表示失败*/
long measureFileSize(char *path);
/*清空一个文件内容,任何格式磁盘文件文件大小变为0,但是不删除该文件*/
void clearFileContent(char *path);
/*将一个长度为L的字符型数组a写入到路径path表示的文件中,flag为1表示在文件末尾追加,为0表示从文件头重新写入*/
void writeCharArrayToFile(char a[], int L, char *path, int flag);
/*将路径path表示的文件内容读取到字符型数组a中,读取长度为L*/
void readFileToCharArray(char a[], int L, char *path);
/*修改路径为path的文件,将它距离文件开头pos字节数的位置的一个字节二进制数据修改为c*/
void changeFileByte(char *path, int pos, char c);
/*修改路径为path的文件,将它距离文件开头pos字节数的位置的L个字节二进制数据修改为*c*/
void changeFileBytes(char *path, int pos, int L, char *c);
/*合并两个文件,使用二进制形式,将一个文件rear添加到另一个文件front的末尾,flag=1表示合并后删除read文件,flag=0表示不删除*/
void combineTwoFileBin(char *front, char *rear, int flag);
/*根据指定路径创建一个目录*/
void makeDir(char *path);
/*统计英文文档大写字母个数,小写字母个数,数字字符数,统计换行符个数,空格字符个数,逗号字符数,其他字符数,按顺序存放在一个长度为7count数组中,path为文件路径 ,L必须为7*/
void statEnglishFile(char *path, int count[], int L);
/*统计双字节字符*/
int statFileDoubleChar(char *path);
/*统计汉字字符,汉字采用GBK编码*/
int statFileChineseChar(char *path);
/*windows下在路径searchpath下搜索文件名前缀为frontname后缀为rearname的文件,如果两者有一个为*代表通配符,统配任何哪种格式的文件,outputfile为存储找到的文件路径信息的文件*/
void searchFileInWindows(char *searchpath, char *frontname, char *rearname, char *outputfile);
/*linux下在路径searchpath下搜索文件名前缀为frontname后缀为rearname的文件,如果两者有一个为*代表通配符,统配任何哪种格式的文件,outputfile为存储找到的文件路径信息的文件*/
void searchFileInLinux(char *searchpath, char *frontname, char *rearname, char *outputfile);
/***************文件加密*****************/
/*移位加密文本文件path为文件路径,endpath为加密后的密文路径,key为秘钥*/
void encryptedFileUseMoveBit(char *path, char *endpath, int key);
/*移位解密文本文件path为文件路径,endpath为解密后的明文路径,key为秘钥*/
void decryptedFileUseMoveBit(char *path, char *endpath, int key);
/*异或加密文件path为文件路径,endpath为加密后的密文路径,key为秘钥*/
void encryptedFileUseXor(char *path, char *endpath, int key);
/*异或解密文件path为文件路径,endpath为解密后的明文路径,key为秘钥*/
void decryptedFileUseXor(char *path, char *endpath, int key);
/*字符串加密文件path为文件路径,endpath为加密后的密文路径,key为秘钥,L为长度*/
void encryptedFileUseChars(char *path, char *endpath, char key[], int L);
/*字符串解密文件path为文件路径,endpath为解密后的明文路径,key为秘钥,L为长度*/
void decryptedFileUseChars(char *path, char *endpath, char key[], int L);
/*文件分割,path为要分割的文件路径name为文件名,count为分割数量,savepath为保存路径,返回-1表示分割失败,0表示成功*/
int splitFile(char *path, int count, char *savepath, char *savename);
/*合并文件,将文件list中每一行指定的文件按行顺序合并为一个大文件bigfile返回-1表示分割失败,0表示成功*/
int mergeFile(char *list, int count, char *bigfile);
/*写入一行文本到文件将一行字符串str写入文件path中,使用系统命令,mode表示模式,非0表示追加模式,0表示重新从头写入*/
void writeStringToFile(char *str, char *path, int mode);
/*写入一行文本到文件将一行字符串str写入文件path中,使用文件指针,mode表示模式,非0表示追加模式,0表示重新从头写入*/
void writeStringToFileUsePointer(char *str, char *path, int mode);
/*打印path这个文本文件内容*/
void printfFileContent(char *path);
/*文本文件查询,在文件path中搜索字符串str,如果找到返回1,没找到返回0,找到后将所在行号和内容打印出来*/
int searchStringInFile(char *substr, char *path);
/*文本文件删除,在文件path中删除字符串substr,temp为临时文件,如果成功返回1,没成功返回0,将删除后的文件打印出来*/
int deleteStringFromFile(char *substr, char *path, char *temp);
/*文本文件修改,在文件path中使用newstr替换字符串substr,temp为临时文件,如果成功返回1,没成功返回0,*/
int changeStringInFile(char *newstr, char *substr, char *path, char *temp);
/*文本文件增加,在文件path中将newstr添加在字符串substr的前面,temp为临时文件,如果成功返回1,没成功返回0,*/
int addStringToFile(char *newstr, char *substr, char *path, char *temp);
/*在文件path中搜索字符串str所在行然后打印出来*/
void printStringInLine(char *substr, char *path);
/*在文件path中读取第n行然后打印出来,*/
void printnLineString(int n, char *path);

/*******************************************************内存操作算法***********************************/
/*内存检索原理,检索int类型整数num,并用newnum进行替换的算法,startadd为起始地址十六进制表示形式,endadd为终止地址十六进制表示形式,返回0表示找到,返回-1表示未找到*/
int searchIntInMemory(int startadd, int endadd, int num, int newnum);

2.这是自己实现的算法库源文件

#define  _CRT_SECURE_NO_WARNINGS
#include "algorithm.h"
/*本算法库封装了大多数常用算法,经过测试,可以直接使用,使用请尊重作者的成果,注明出处*/

/*******************************************************内存操作算法***********************************/
/*内存检索原理,检索int类型整数num,并用newnum进行替换的算法,startadd为起始地址十六进制表示形式,endadd为终止地址十六进制表示形式,返回0表示找到,返回-1表示未找到*/
int searchIntInMemory(int startadd, int endadd, int num, int newnum)
{
    void * start = (void *)startadd;
    void * end = (void *)endadd;
    for (char *p = start; p < end; p++)//一次移动一个字节,遍历地址空间
    {
        int *pnum = (int *)p;//pnum每次从p开始的地址取四个字节
        if (*pnum == num)
        {
            *pnum = newnum;
            return 0;
        }

    }
    return -1;
}

/********************************************排序查询类算法********************************************/
/*二分查找法,上,中,下,前提数组必须有序找到返回0否则返回-1*/
int binerySearch(char **p, int count, char *des)
{
    int low = 0;
    int high = count;
    while (low < high)
    {
        int mid = (low + count) / 2;
        if (strcmp(des, p[mid]) < 0)
        {
            high = mid - 1;
        }
        else if (strcmp(des, p[mid]) > 0)
        {
            low = mid + 1;
        }
        else
        {
            printf("找到了");
            return 0;
        }
    }
    return -1;


}



/********************************************数学类算法********************************************/
/*乘法表打印方形*/
void print9X9Table()
{

    for (int i = 1; i <= 9; i++)
    {

        for (int j = 1; j <= 9; j++)
        {
            printf("%d X %d = %d\t", i, j, i*j);
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}

/*乘法表打印反对角线以下*/
void print9X9Table1()
{
    for (int i = 1; i <= 9; i++)
    {

        for (int j = 1; j <= 9; j++)
        {
            if (i >= j)
                printf("%d X %d = %d\t", i, j, i*j);
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}

/*乘法表打印反对角线以上*/
void print9X9Table2()
{
    for (int i = 1; i <= 9; i++)
    {

        for (int j = 1; j <= 9; j++)
        {
            if (i <= j)
            {
                printf("%d X %d = %d\t", i, j, i*j);
            }
            else
            {
                printf("         \t");
            }
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}

/*乘法表打印正对角线以上*/
void print9X9Table3()
{
    for (int i = 1; i <= 9; i++)
    {

        for (int j = 1; j <= 9; j++)
        {
            if (i + j <= 10)
            {
                printf("%d X %d = %d\t", i, j, i*j);
            }

        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}

/*乘法表打印反对角线以下*/
void print9X9Table4()
{
    for (int i = 1; i <= 9; i++)
    {

        for (int j = 1; j <= 9; j++)
        {
            if (i + j >= 10)
            {
                printf("%d X %d = %d\t", i, j, i*j);
            }
            else
            {
                printf("         \t");
            }
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}


/*乘法表打印反对角线上的*/
void print9X9Table5()
{
    for (int i = 1; i <= 9; i++)
    {

        for (int j = 1; j <= 9; j++)
        {
            if (i == j)
            {
                printf("%d X %d = %d\t", i, j, i*j);
            }
            else
            {
                printf("         \t");
            }
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}
/*乘法表打印正对角线上的*/
void print9X9Table6()
{
    for (int i = 1; i <= 9; i++)
    {

        for (int j = 1; j <= 9; j++)
        {
            if (i + j == 10)
            {
                printf("%d X %d = %d\t", i, j, i*j);
            }
            else
            {
                printf("         \t");
            }
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}

/*乘法表打印两条对角线上部的*/
void print9X9TableUp()
{
    printf("上部区域:\n");
    for (int i = 1; i <= 9; i++)
    {

        for (int j = 1; j <= 9; j++)
        {
            if (i < j && (i + j < 10))
            {
                printf("%d X %d = %d\t", i, j, i*j);
            }
            else
            {
                printf("         \t");
            }
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}
/*乘法表打印两条对角线下部的*/
void print9X9TableDown()
{
    printf("下部区域:\n");
    for (int i = 1; i <= 9; i++)
    {

        for (int j = 1; j <= 9; j++)
        {
            if (i > j && (i + j > 10))
            {
                printf("%d X %d = %d\t", i, j, i*j);
            }
            else
            {
                printf("         \t");
            }
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}
/*乘法表打印两条对角线左边的*/
void print9X9TableLeft()
{
    printf("左部区域:\n");
    for (int i = 1; i <= 9; i++)
    {

        for (int j = 1; j <= 9; j++)
        {
            if (i > j && (i + j < 10))
            {
                printf("%d X %d = %d\t", i, j, i*j);
            }
            else
            {
                printf("         \t");
            }
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}
/*乘法表打印两条对角线右边的的*/
void print9X9TableRight()
{
    printf("右部区域:\n");
    for (int i = 1; i <= 9; i++)
    {

        for (int j = 1; j <= 9; j++)
        {
            if (i < j && (i + j > 10))
            {
                printf("%d X %d = %d\t", i, j, i*j);
            }
            else
            {
                printf("         \t");
            }
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}

/*求2的N次方*/
int T2n(int N)
{
    int i = 1;
    int num = 1;
    for (; i <= N; i++)
    {
        num *= 2;
    }
    return num;
}
/*求2的一次方到2的N次方的和*/
int S2n(int N)
{
    int i = 1;
    int num = 0;
    for (; i <= N; i++)
    {
        num += T2n(i);
    }
    return num;
}
/*求两个数的最大公因数 a > b*/
int maxCommonFactor(int a, int b)
{
    int r = 0;
    while ( b != 0)
    {
        r = a % b;
        a = b;
        b = r;
    }
    return a;
}
/*求两个数的最小公倍数*/
int minCommonDouble(int a, int b)
{
    int m = maxCommonFactor(a, b);
    return (a*b) / m;
}
/*获取N以下的质数,并按从小到大的顺序存放到数组P中,L为存放质数个数地址*/
void getPrimeNumTable(int N,int *P,int *L)
{
    int T = 0;
    int m = 0;
    for (int j = 2; j <= N; j++)
    {
        T = sqrt(j);
        int i;
        for (i = 2; i <= T; i++)
        {
            if (j % i == 0 )
            {
                break;
            }
        }
        if (i > T)
        {
            P[m++] = j;
        }
        if (m > L - 1)
            return;
    }
    *L = m;

}
/*求一个数的所有质因数,并按从小到大的顺序存放到数组P中,L为存放质因数个数地址,F为中间获取质数的数组表,T为存储质数数组长度的变量*/
int getFactor(int m,int *P,int *F,int *L,int *T)
{

    int n = 0;

    getPrimeNumTable(m, F, T);

    for (int i = 0; i < *T; i++)
    {
        if (m % F[i] == 0)
        {
            P[n++] = F[i];
            
        }
    }
    *L= n;
    return n;
}


/*使用递归10进制转0进制打印*/
void  PrintBin(int n)
{
    if (n == 0)
    {
        return;
    }
    else
    {
        int x = n % 2;//只要将2改为8,或16就可以转换为8进制或16进制
        n /= 2;
        //printf("%d", x);放在递归调用之前,则会先打印,二进制反序
        PrintBin(n);
        printf("%d", x);//放在递归调用之后,则会最后执行打印
    }
}
/*穷举法求13X+12Y=100的整数解,X = (100 - 12Y)/ 13 为整数*/
void getEquationValue()
{
    for (int i = 0;; i++)
    {
        if ((100 - 12 * i) % 13 == 0)
        {
            printf("整数解为:X = %d,Y = %d\n", (100 - 12 * i) / 13, i);
            break;
        }
    }
    system("pause");
}

/*二进制整数转十进制,接受一个二进制字符串,将它转为10进制整数数*/
int BinToDec(char *bin)
{
    char *p;
    int len = 0;//统计二进制位数
    int num = 0;

    for (p = bin; *p != '\0'; p++)
    {
        if ((*p) != '0' && (*p) != '1')
        {
            printf("%d", *p);
            printf("您输入的二进制整数不合法");
            return 0;
        }
        len++;
        if (len > 32)
        {
            printf("您输入的位数过多");
            return 0;
        }
        num = num * 2 + (*p - 48);
    }
    return num;




}
/*十进制整数转二进制字符串*/
char *DecToBin(int num, char *s)
{
    char *p;
    char *q;
    p = s;
    char c;
    while (num >= 1)
    {
        *p = num % 2 + '0';
        //printf("%c", *p);
        num = num / 2;
        printf("%c\n", *p);
        p++;

    }
    *p = '\0';
    q = p;
    q--;
    for (p = s; p < q; p++, q--)
    {

        c = *p;
        *p = *q;
        *q = c;

    }
    printf("%s\n", s);
    return s;

}
/*求一个数对另一个数的余数,不使用求模运算符*/
int YuNum(int a, int b)
{
    int y;
    y = a - (a / b) * b;
    return y;
}
/*求一个整数的翻转*/
int ReverseInt(int num)
{

    int tem = num;
    int m = 0;
    while (tem != 0)
    {
        m = m * 10 + tem % 10;

        tem /= 10;

    }
    return m;
}
/*取出一个整数的每个位,存入到一个数组中,第一个为个位,依次类推*/
int GetIntBit(int num, int bit[])
{
    int tem = num;
    int i = 0;

    while (tem != 0)
    {
        bit[i] = tem % 10;
        i++;
        tem /= 10;

    }
    return i;
}
/*产生一个N之内的随机数*/
int  RandomNumber(int N)
{
    //以时间为种子创建随机数
    time_t tm = 0;
    srand((unsigned int)time(tm));//定义随机数种子,没用种子的话rand产生的随机数不会变
    int random = rand() % N;//产生0-100之间的随机数
    return random;

}

/*判断一个n位数num是不是水仙花数,每一位的数字由低到高存入bit数组中*/
int searchNumber(int num, int n, int bit[])
{

    for (int i = 0; i < n; i++)
    {
        int temp = 1;
        for (int j = 0; j < i; j++)
        {
            temp *= 10;
        }
        bit[i] = num / temp % 10;
    }

    int tcf = 0;
    for (int i = 0; i < n; i++)
    {
        tcf += bit[i] * bit[i] * bit[i];
    }
    if (num == tcf)
    {
        printf("%d\n", num);
        return 0;
    }
    return -1;

}

/*生成n个小于m的随机数,并将生成的随机数存放到数组p中*/
void randNumber(int *p, int n, int m)
{
    time_t tm = 0;//时间数据类型
    unsigned int ctime = (unsigned int)tm;
    srand(ctime);//以时间做种子生成随机数
    for (int i = 0; i < n; i++)
    {
        p[i] = rand() % m;
    }
}



/********************************************逻辑类算法****************************************/
/*置位int数num的第N个位*/
void setInt(int *num, int N)
{
    if (N > 31)
    {
        printf("超出置位范围0-31");
        return;
    }
    *num |= (1 << N);
}
/*清零int数num的第N个位*/
void clearInt(int *num, int N)
{
    if (N > 32)
    {
        printf("超出置位范围0-31");
        return;
    }
    *num &= ~(1 << N);
}
/*统计num中是1的位数,返回位数*/
int statIntOne(int num)
{
    int count = 0;

    for (int i = 0; i < 32; i++)
    {
        int t = num & 1;
        if (t == 1)
            count++;

        num = num >> 1;
    }
    return count;

}
/*统计num中是0的位数,返回位数*/
int statIntZero(int num)
{
    int count = 0;

    for (int i = 0; i < 32; i++)
    {
        int t = num & 1;
        if (t == 0)
            count++;

        num = num >> 1;
    }
    return count;

}
/*翻转一个int数,即高位和低位互换 0位和31位互换,1位和30维护换返回位数*/
int reverseInt(int *num)
{

    int tem = *num;
    for (int i = 0; i < 32; i++)
    {
        int t = tem & 1;//1.取出每一位的值,

        //2.将第0位的值置给31,第一位的值置给30
        if (t == 1)//
        {
            setInt(num, 31 - i);
            //printf("%d\n", *num);
        }
        else
        {

            clearInt(num, 31 - i);
            //printf("%d\n", *num);
        }
        tem = tem >> 1;



    }

    return *num;

}
/*以二进制形式打印一个整数*/
void printfIntBinary(int num)
{
    reverseInt(&num);
    for (size_t i = 0; i < 32; i++)
    {

        int t = num & 1;
        printf("%d", t);
        num = num >> 1;
    }
}
/*循环左移位的实现num左移N位*/
int moveToLeft(int num, int N)
{
    for (int i = 0; i < N; i++)
    {
        int t = num & (1 << 31);//1.取出最高位的值,
        num = num << 1;//左移一位
        //2.先将第0位的值置给31,
        if (t != 0)//
        {
            setInt(&num, 0);
            //printf("%d\n", *num);
        }
        else
        {

            clearInt(&num, 0);
            //printf("%d\n", *num);
        }
    }
    return num;

}
/*循环右移位的实现num右移N位*/
int moveToRight(int num, int N)
{
    for (int i = 0; i < N; i++)
    {
        int t = num & 1;//1.取出每一位的值,
        num = num >> 1;
        //2.先将第0位的值置给31,
        if (t == 1)//
        {
            setInt(&num, 31);
            //printf("%d\n", *num);
        }
        else
        {

            clearInt(&num, 31);
            //printf("%d\n", *num);
        }

    }
    return num;

}
/*使用位运算异或实现两个变量值的交换*/
void exchange(int *a, int *b)
{
    *a = (*a) ^ (*b);
    *b = (*a) ^ (*b);
    *a = (*a) ^ (*b);
}
/*获取int数num的第m个位的值,0或1*/
int getIntBit(int num, int m)
{
    if (m > 31)
    {
        printf("超出置位范围0-31");
        return -1;
    }
    int t = (num  & (1 << m));
    if (t == 0)
    {
        return 0;
    }
    else
    {
        return 1;
    }

}
/*打印一个int数在内存中的二进制码,正数就是它的原码,负数就是它的补码*/
void printfBinCode(int num)
{
    int m = 31;
    while (m >= 0)
    {
        if (getIntBit(num, m))
        {
            printf("1");
        }
        else
        {
            printf("0");
        }
        m--;
    }
}
/*输出一个int数的原码,正数就是它的二进制码,负数就是对应二进制码(反码)的原码*/
void printfSrcCode(int num)
{
    if (num >= 0)
    {
        printfBinCode(num);
    }
    else
    {
        num = num - 1;
        num = ~num;
        setInt(&num, 31);
        printfBinCode(num);



    }
}

/*打印一个unsigned char 类型的二进制码*/
void printfCharCode(unsigned char s)
{
    int m = 7;
    while (m >= 0)
    {
        if (getIntBit(s, m))
        {
            printf("1");
        }
        else
        {
            printf("0");
        }
        m--;
    }
}
/*打印一个浮点数的二进制码*/
void printfFloatCode(float f)
{
    unsigned char *p;
    p = (unsigned char *)&f;
    int N = 3;
    while (N >= 0)
    {
        printfCharCode(*(p + N));
        N--;
    }



}
/*求一元二次方程的根*/
void get2CiEquation(double a,double b,double c)
{
    printf("你要求解的一元二次方程是:%lf*x*x + %lf*x + %lf = 0\n", a, b, c);
    if (a)//如果a不等于0
    {
        double m = b*b - 4 * a*c;
        double n = -1 * b / 2 / a;
        if (m == 0)
        {
            printf("有两个相等的实数根:x1 = x2 = %lf", n);
        }
        else if (m > 0)
        {
            printf("有两个不相等的实数根:x1 = %lf,x2 = %lf", n - sqrt(m) / 2 / a, n + sqrt(m) / 2 / a);
        }
        else
        {
            printf("有两个不相等的虚数根:x1 = %lf+%lfi,x2 = %lf-%lfi", n, sqrt(-m) / 2 / a, n, sqrt(-m) / 2 / a);
        }
    }
    else//a = 0
    {
        if (b)//b != 0
        {
            printf("方程为一元方程其根为:x = %lf", c / b);
        }
        else
        {
            if (c)// C != 0
            {
                printf("该方程无根");
            }
            else
            {
                printf("有无数个实数根");
            }

        }

    }
}


/*********************************************Windows操作算法******************************************/
/*模拟鼠标单击*/
void SingleClick()
{
    mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);//鼠标左键按下
    mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);//鼠标左键抬起,一组按下和抬起构成一次点击
}
/*模拟鼠标双击*/
void DoubleClick()
{
    mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);//鼠标左键按下
    mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);//鼠标左键抬起,一组按下和抬起构成一次点击
    mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);//鼠标左键按下
    mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);//鼠标左键抬起,一组按下和抬起构成一次点击
}
/*模拟鼠标右击*/
void RightClick()
{
    mouse_event(MOUSEEVENTF_RIGHTDOWN, 0, 0, 0, 0);//鼠标左键按下
    mouse_event(MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0);//鼠标左键抬起,一组按下和抬起构成一次点击

}
/*Left mouse button键的模拟*/
void LeftMouseButton()
{
    keybd_event(0x01, 0, 0, 0);//键盘模拟
    keybd_event(0x01, 0, 2, 0);//键盘模拟
}

/*Right mouse button键的模拟*/
void RightMouseButton()
{
    keybd_event(0x01, 0, 0, 0);//键盘模拟
    keybd_event(0x01, 0, 2, 0);//键盘模拟
}
/*Control-break processing键的模拟*/
void Cancle()
{
    keybd_event(0x03, 0, 0, 0);//键盘模拟
    keybd_event(0x03, 0, 2, 0);//键盘模拟
}
/*鼠标中键的模拟*/
void MiddleButton()
{
    keybd_event(0x04, 0, 0, 0);//键盘模拟
    keybd_event(0x04, 0, 2, 0);//键盘模拟
}
/*backspace键的模拟*/
void Backspace()
{
    keybd_event(0x08, 0, 0, 0);
    keybd_event(0x08, 0, 2, 0);
}
/*TAB key键的模拟*/
void Tab()
{
    keybd_event(0x09, 0, 0, 0);
    keybd_event(0x09, 0, 2, 0);
}
/*CLEAR key键的模拟*/
void ClearKey()
{
    keybd_event(0x0C, 0, 0, 0);
    keybd_event(0x0C, 0, 2, 0);
}
/*ENTER回车键 key键的模拟*/
void Enter()
{
    keybd_event(0x0D, 0, 0, 0);
    keybd_event(0x0D, 0, 2, 0);
}
/*SHIFT key键的模拟*/
void Shift()
{
    keybd_event(0x10, 0, 0, 0);
    keybd_event(0x10, 0, 2, 0);
}
/*CTRL key键的模拟*/
void Ctrl()
{
    keybd_event(0x11, 0, 0, 0);
    keybd_event(0x11, 0, 2, 0);
}
/*ALT key键的模拟*/
void Alt()
{
    keybd_event(0x12, 0, 0, 0);
    keybd_event(0x12, 0, 2, 0);
}
/*PAUSE key键的模拟*/
void Pause()
{
    keybd_event(0x13, 0, 0, 0);
    keybd_event(0x13, 0, 2, 0);
}

/*CAPS LOCK key键的模拟*/
void CapsLock()
{
    keybd_event(0x14, 0, 0, 0);
    keybd_event(0x14, 0, 2, 0);
}
/*ESC key键的模拟*/
void Esc()
{
    keybd_event(0x1B, 0, 0, 0);
    keybd_event(0x1B, 0, 2, 0);
}
/*SPACE空格 key键的模拟*/
void Space()
{
    keybd_event(0x20, 0, 0, 0);
    keybd_event(0x20, 0, 2, 0);
}
/*PAGE UP key键的模拟*/
void PageUp()
{
    keybd_event(0x21, 0, 0, 0);
    keybd_event(0x21, 0, 2, 0);
}
/*PAGE DOWN key键的模拟*/
void PageDown()
{
    keybd_event(0x22, 0, 0, 0);
    keybd_event(0x22, 0, 2, 0);
}
/*END key键的模拟*/
void End()
{
    keybd_event(0x23, 0, 0, 0);
    keybd_event(0x23, 0, 2, 0);
}
/*Home key键的模拟*/
void Home()
{
    keybd_event(0x24, 0, 0, 0);
    keybd_event(0x24, 0, 2, 0);
}
/*LEFT ARROW key键的模拟*/
void LeftArrow()
{
    keybd_event(0x25, 0, 0, 0);
    keybd_event(0x25, 0, 2, 0);
}
/*RIGHT ARROW key键的模拟*/
void RightArrow()
{
    keybd_event(0x27, 0, 0, 0);
    keybd_event(0x27, 0, 2, 0);
}
/*UP ARROW key键的模拟*/
void UpArrow()
{
    keybd_event(0x26, 0, 0, 0);
    keybd_event(0x26, 0, 2, 0);
}
/*DOWN ARROW key键的模拟*/
void DownArrow()
{
    keybd_event(0x28, 0, 0, 0);
    keybd_event(0x28, 0, 2, 0);
}
/*SELECT key键的模拟*/
void Select()
{
    keybd_event(0x29, 0, 0, 0);
    keybd_event(0x29, 0, 2, 0);
}
/*EXECUTE key键的模拟*/
void Execute()
{
    keybd_event(0x2B, 0, 0, 0);
    keybd_event(0x2B, 0, 2, 0);
}
/*PRINT SCREEN key键的模拟*/
void PrintScreen()
{
    keybd_event(0x2C, 0, 0, 0);
    keybd_event(0x2C, 0, 2, 0);
}
/*INSERT key键的模拟*/
void Insert()
{
    keybd_event(0x2D, 0, 0, 0);
    keybd_event(0x2D, 0, 2, 0);
}
/*DELETE key键的模拟*/
void Delete()
{
    keybd_event(0x2E, 0, 0, 0);
    keybd_event(0x2E, 0, 2, 0);
}
/*HELP key键的模拟*/
void Help()
{
    keybd_event(0x2F, 0, 0, 0);
    keybd_event(0x2F, 0, 2, 0);
}

/*Left Windows key键的模拟*/
void LeftWin()
{
    keybd_event(0x5B, 0, 0, 0);
    keybd_event(0x5B, 0, 2, 0);
}
/*Right Windows key键的模拟*/
void RightWin()
{
    keybd_event(0x5C, 0, 0, 0);
    keybd_event(0x5C, 0, 2, 0);
}
/*0 key键的模拟*/
void NumberThero()
{
    keybd_event(0x60, 0, 0, 0);
    keybd_event(0x60, 0, 2, 0);
}
/*1 key键的模拟*/
void NumberOne()
{
    keybd_event(0x61, 0, 0, 0);
    keybd_event(0x61, 0, 2, 0);
}
/*2 key键的模拟*/
void NumberTwo()
{
    keybd_event(0x62, 0, 0, 0);
    keybd_event(0x62, 0, 2, 0);
}
/*3 key键的模拟*/
void NumberThree()
{
    keybd_event(0x63, 0, 0, 0);
    keybd_event(0x63, 0, 2, 0);
}
/*4 key键的模拟*/
void NumberFour()
{
    keybd_event(0x64, 0, 0, 0);
    keybd_event(0x64, 0, 2, 0);
}
/*5 key键的模拟*/
void NumberFive()
{
    keybd_event(0x65, 0, 0, 0);
    keybd_event(0x65, 0, 2, 0);
}
/*6 key键的模拟*/
void NumberSix()
{
    keybd_event(0x66, 0, 0, 0);
    keybd_event(0x66, 0, 2, 0);
}
/*7 key键的模拟*/
void NumberSeven()
{
    keybd_event(0x67, 0, 0, 0);
    keybd_event(0x67, 0, 2, 0);
}
/*8 key键的模拟*/
void NumberEight()
{
    keybd_event(0x68, 0, 0, 0);
    keybd_event(0x68, 0, 2, 0);
}
/*9 key键的模拟*/
void NumbeNine()
{
    keybd_event(0x69, 0, 0, 0);
    keybd_event(0x69, 0, 2, 0);
}
/*乘号 key键的模拟*/
void Multiply()
{
    keybd_event(0x6A, 0, 0, 0);
    keybd_event(0x6A, 0, 2, 0);
}
/*加号 key键的模拟*/
void Add()
{
    keybd_event(0x6B, 0, 0, 0);
    keybd_event(0x6B, 0, 2, 0);
}
/*减号 Subtractkey键的模拟*/
void Subtract()
{
    keybd_event(0x6D, 0, 0, 0);
    keybd_event(0x6D, 0, 2, 0);
}
/*除号 /键的模拟*/
void Divide()
{
    keybd_event(0x6F, 0, 0, 0);
    keybd_event(0x6F, 0, 2, 0);
}
/*Separator 分隔符 \ 键的模拟*/
void Separator()
{
    keybd_event(0x6C, 0, 0, 0);
    keybd_event(0x6C, 0, 2, 0);
}
/*F1键的模拟*/
void F1()
{
    keybd_event(0x70, 0, 0, 0);
    keybd_event(0x70, 0, 2, 0);
}
/*F2键的模拟*/
void F2()
{
    keybd_event(0x71, 0, 0, 0);
    keybd_event(0x71, 0, 2, 0);
}
/*F3键的模拟*/
void F3()
{
    keybd_event(0x72, 0, 0, 0);
    keybd_event(0x72, 0, 2, 0);
}
/*F4键的模拟*/
void F4()
{
    keybd_event(0x73, 0, 0, 0);
    keybd_event(0x73, 0, 2, 0);
}
/*F5键的模拟*/
void F5()
{
    keybd_event(0x74, 0, 0, 0);
    keybd_event(0x74, 0, 2, 0);
}
/*F6键的模拟*/
void F6()
{
    keybd_event(0x75, 0, 0, 0);
    keybd_event(0x75, 0, 2, 0);
}
/*F7键的模拟*/
void F7()
{
    keybd_event(0x76, 0, 0, 0);
    keybd_event(0x76, 0, 2, 0);
}
/*F8键的模拟*/
void F8()
{
    keybd_event(0x77, 0, 0, 0);
    keybd_event(0x77, 0, 2, 0);
}
/*F9键的模拟*/
void F9()
{
    keybd_event(0x78, 0, 0, 0);
    keybd_event(0x78, 0, 2, 0);
}
/*F10键的模拟*/
void F10()
{
    keybd_event(0x79, 0, 0, 0);
    keybd_event(0x79, 0, 2, 0);
}
/*F11键的模拟*/
void F11()
{
    keybd_event(0x7A, 0, 0, 0);
    keybd_event(0x7A, 0, 2, 0);
}
/*F12键的模拟*/
void F12()
{
    keybd_event(0x7B, 0, 0, 0);
    keybd_event(0x7B, 0, 2, 0);
}
/*F13键的模拟*/
void F13()
{
    keybd_event(0x7C, 0, 0, 0);
    keybd_event(0x7C, 0, 2, 0);
}
/*F14键的模拟*/
void F14()
{
    keybd_event(0x7D, 0, 0, 0);
    keybd_event(0x7D, 0, 2, 0);
}
/*F15键的模拟*/
void F15()
{
    keybd_event(0x7E, 0, 0, 0);
    keybd_event(0x7E, 0, 2, 0);
}
/*F16键的模拟*/
void F16()
{
    keybd_event(0x7F, 0, 0, 0);
    keybd_event(0x7F, 0, 2, 0);
}
/*NUM LOCK键的模拟*/
void NumLock()
{
    keybd_event(0x90, 0, 0, 0);
    keybd_event(0x90, 0, 2, 0);
}
/* ";:" 键的模拟*/
void ColonAndSemicolon()
{
    keybd_event(0xBA, 0, 0, 0);
    keybd_event(0xBA, 0, 2, 0);
}
/* "+ =" 键的模拟*/
void PlusEquals()
{
    keybd_event(0xBB, 0, 0, 0);
    keybd_event(0xBB, 0, 2, 0);
}
/* "," 键的模拟*/
void Comma()
{
    keybd_event(0xBC, 0, 0, 0);
    keybd_event(0xBC, 0, 2, 0);
}
/* "- _" 键的模拟*/
void MinusHyphen()
{
    keybd_event(0xBD, 0, 0, 0);
    keybd_event(0xBD, 0, 2, 0);
}
/* "." 键的模拟*/
void Point()
{
    keybd_event(0xBE, 0, 0, 0);
    keybd_event(0xBE, 0, 2, 0);
}
/* "/ ?" 键的模拟*/
void Question()
{
    keybd_event(0xBF, 0, 0, 0);
    keybd_event(0xBF, 0, 2, 0);
}
/* "` ~" 键的模拟*/
void BoLangHao()
{
    keybd_event(0xC0, 0, 0, 0);
    keybd_event(0xC0, 0, 2, 0);
}
/* "[ {" 键的模拟*/
void LeftBrackets()
{
    keybd_event(0xDB, 0, 0, 0);
    keybd_event(0xDB, 0, 2, 0);
}
/* "\ |" 键的模拟*/
void VerticalLine()
{
    keybd_event(0xDC, 0, 0, 0);
    keybd_event(0xDC, 0, 2, 0);
}
/* "] }" 键的模拟*/
void RightBrackets()
{
    keybd_event(0xDD, 0, 0, 0);
    keybd_event(0xDD, 0, 2, 0);
}
/* "' "" 键的模拟*/
void YinHao()
{
    keybd_event(0xDE, 0, 0, 0);
    keybd_event(0xDE, 0, 2, 0);
}
/*win键的模拟*/
void win()
{
    keybd_event(0x5b, 0, 0, 0);//键盘模拟win键按下
    keybd_event(0x5b, 0, 2, 0);//键盘模拟win键松开
}
/*win+d键的组合模拟*/
void winAndD()
{
    keybd_event(0x5b, 0, 0, 0);//键盘模拟键盘按下
    keybd_event('D', 0, 0, 0);//D键按下
    keybd_event('D', 0, 2, 0);//D键松开
    keybd_event(0x5b, 0, 2, 0);//键盘模拟键盘松开
}
/*win+E键的组合模拟*/
void winAndE()
{
    keybd_event(0x5b, 0, 0, 0);//键盘模拟键盘按下
    keybd_event('E', 0, 0, 0);//D键按下
    keybd_event('E', 0, 2, 0);//D键松开
    keybd_event(0x5b, 0, 2, 0);//键盘模拟键盘松开
}
/*win+M键的组合模拟*/
void winAndM()
{
    keybd_event(0x5b, 0, 0, 0);//键盘模拟键盘按下
    keybd_event('M', 0, 0, 0);//D键按下
    keybd_event('M', 0, 2, 0);//D键松开
    keybd_event(0x5b, 0, 2, 0);//键盘模拟键盘松开
}
/*CTRL+ALT+DEL键的组合模拟*/
void ctrlAndAltAndDel()
{
    keybd_event(0x11, 0, 0, 0);    //    CTRL键按下
    keybd_event(0x12, 0, 0, 0);
    keybd_event(0x2E, 0, 0, 0);
    keybd_event(0x2E, 0, 2, 0);
    keybd_event(0x12, 0, 2, 0);
    keybd_event(0x11, 0, 2, 0);//ctrl键松开
}
/*****************************************26个英文字母键模拟*****************************************/
/*A键模拟*/
void AKey()
{
    keybd_event('A', 0, 0, 0);//A键按下
    keybd_event('A', 0, 2, 0);//A键松开
}
/*B键模拟*/
void BKey()
{
    keybd_event('B', 0, 0, 0);
    keybd_event('B', 0, 2, 0);
}
/*C键模拟*/
void CKey()
{

    keybd_event('C', 0, 0, 0);
    keybd_event('C', 0, 2, 0);
}
/*D键模拟*/
void DKey()
{
    keybd_event('D', 0, 0, 0);
    keybd_event('D', 0, 2, 0);
}
/*E键模拟*/
void EKey()
{
    keybd_event('E', 0, 0, 0);
    keybd_event('E', 0, 2, 0);
}
/*F键模拟*/
void FKey()
{
    keybd_event('F', 0, 0, 0);
    keybd_event('F', 0, 2, 0);
}
/*G键模拟*/
void GKey()
{
    keybd_event('G', 0, 0, 0);
    keybd_event('G', 0, 2, 0);

}
/*H键模拟*/
void HKey()
{
    keybd_event('H', 0, 0, 0);
    keybd_event('H', 0, 2, 0);
}
/*I键模拟*/
void IKey()
{
    keybd_event('I', 0, 0, 0);
    keybd_event('I', 0, 2, 0);
}
/*J键模拟*/
void JKey()
{
    keybd_event('J', 0, 0, 0);
    keybd_event('J', 0, 2, 0);
}
/*K键模拟*/
void KKey()
{
    keybd_event('K', 0, 0, 0);
    keybd_event('K', 0, 2, 0);
}
/*L键模拟*/
void LKey()
{
    keybd_event('L', 0, 0, 0);
    keybd_event('L', 0, 2, 0);
}
/*M键模拟*/
void MKey()
{
    keybd_event('M', 0, 0, 0);
    keybd_event('M', 0, 2, 0);
}
/*N键模拟*/
void NKey()
{
    keybd_event('N', 0, 0, 0);
    keybd_event('N', 0, 2, 0);
}
/*O键模拟*/
void OKey()
{
    keybd_event('O', 0, 0, 0);
    keybd_event('O', 0, 2, 0);
}
/*P键模拟*/
void PKey()
{
    keybd_event('P', 0, 0, 0);
    keybd_event('P', 0, 2, 0);
}
/*Q键模拟*/
void QKey()
{
    keybd_event('Q', 0, 0, 0);
    keybd_event('Q', 0, 2, 0);
}
/*R键模拟*/
void RKey()
{
    keybd_event('R', 0, 0, 0);
    keybd_event('R', 0, 2, 0);
}
/*S键模拟*/
void SKey()
{
    keybd_event('S', 0, 0, 0);
    keybd_event('S', 0, 2, 0);
}
/*T键模拟*/
void TKey()
{
    keybd_event('T', 0, 0, 0);
    keybd_event('T', 0, 2, 0);
}
/*U键模拟*/
void UKey()
{
    keybd_event('U', 0, 0, 0);
    keybd_event('U', 0, 2, 0);
}
/*V键模拟*/
void VKey()
{
    keybd_event('V', 0, 0, 0);
    keybd_event('V', 0, 2, 0);
}
/*W键模拟*/
void WKey()
{
    keybd_event('W', 0, 0, 0);
    keybd_event('W', 0, 2, 0);
}
/*X键模拟*/
void XKey()
{
    keybd_event('X', 0, 0, 0);
    keybd_event('X', 0, 2, 0);
}
/*Y键模拟*/
void YKey()
{
    keybd_event('Y', 0, 0, 0);
    keybd_event('Y', 0, 2, 0);
}
/*Z键模拟*/
void ZKey()
{
    keybd_event('Z', 0, 0, 0);
    keybd_event('Z', 0, 2, 0);
}




/*********************************************字符串算法*********************************************/
/*自己实现的字符串检索函数,s2为要检索的字符串,s1位源字符串*/
int strInStrPos(char s1[], char s2[])
{
    int length1 = strlen(s1);
    int length2 = strlen(s2);
    printf("length1 = %d,length2 = %d", length1, length2);
    //找到标记 -1表示未找到
    int pos = -1;
    for (int i = 0; i <= length1 - length2; i++)
    {
        int j = 0;
        for (; j < length2; j++)
        {
            if (s1[i + j] != s2[j])
            {
                break;
            }

        }
        if (j == length2)
            pos = i;

    }
    return pos;

}
/*打印hello的8种方式打印八个hello*/
void printHello()
{
    printf("%s\n", "hello");
    printf("hello\n");
    printf("%c%c%c%c%c\n", 'h', 'e', 'l', 'l', 'o');
    printf("%c%c%c%c%c\n", 104, 101, 108, 108, 111);
    printf("%c%c%c%c%c\n", 0150, 0145, 0154, 0154, 0157);
    printf("%c%c%c%c%c\n", 0x68, 0x65, 0x6c, 0x6c, 0x6f);
    printf("%c%c%c%c%c\n", '\150', '\145', '\154', '\154', '\157');
    printf("%c%c%c%c%c\n", '\x68', '\x65', '\x6c', '\x6c', '\x6f');
    //%f 带小数点的实数%e指数形式的浮点数%g看%f和%e谁短以谁的形式打印,并去掉无用的部分
    
}

/*从一个字符串str中删除一个子串substr*/
void deleteStringInString(char *substr, char *str)
{
    int lenstr = strlen(str);
    int lensub = strlen(substr);
    printf("%d\n", lenstr);
    printf("%d\n", lensub);
    char *p = strstr(str, substr);
    printf("%s\n", p);
    if (p != NULL)
    {
        int i = 0;
        for (; p[i + lensub] != '\0'; i++)
        {
            p[i] = p[i + lensub];
            printf("%c\n", p[i + lensub]);
        }
        p[i] = '\0';
    }
}

/*从一个字符串str中使用newstr替换一个子串substr*/
void changeStringInString(char *newstr, char *substr, char *str)
{
    int lenstr = strlen(str);
    int lensub = strlen(substr);
    int lennew = strlen(newstr);
    printf("%d\n", lenstr);
    printf("%d\n", lensub);
    char *p = strstr(str, substr);
    printf("%s\n", p);
    if (p != NULL)
    {


        if (lensub > lennew)
        {
            for (int j = 0; j < lennew; j++)
            {
                p[j] = newstr[j];
            }
            int i = 0;
            for (; p[i + lensub] != '\0'; i++)
            {
                p[i + lennew] = p[i + lensub];
                //printf("%c\n", p[i + lensub]);
            }
            p[i] = '\0';
        }
        else
        {
            int j = 0;

            char temp[100];
            while (p[j + lensub] != '\0')
            {
                temp[j + lensub] = p[j + lensub];
                j++;
            }
            temp[j] = '\0';

            for (j = 0; j < lennew; j++)
            {
                p[j] = newstr[j];
            }
            while (temp[j] != '\0')
            {
                p[j] = temp[j];
                j++;
            }
            p[j] = '\0';

        }

    }
}


/*从一个字符串str中子串substr的前面增加一个新字符串newstr*/
void addStringInString(char *newstr, char *substr, char *str)
{
    int lenstr = strlen(str);
    int lensub = strlen(substr);
    int lennew = strlen(newstr);
    printf("%d\n", lenstr);
    printf("%d\n", lensub);
    char *p = strstr(str, substr);
    printf("%s\n", p);
    if (p != NULL)
    {



        int j = 0;
        char temp[200];
        while (p[j] != '\0')
        {
            temp[j] = p[j];//将substr开始以后的所有字符保存起来
            j++;
        }
        temp[j] = '\0';

        for (j = 0; j < lennew; j++)//将新字符串一个一个写入p
        {
            p[j] = newstr[j];
        }
        int i = 0;
        while (temp[i] != '\0')
        {
            p[j] = temp[i];
            i++;
            j++;
        }
        p[j] = '\0';


    }
}

/**********************************************经典算法**********************************************/
/*河内之塔算法
问题描述:三个柱子A,B,C,A上放有N个盘子,盘子从上往下依次增大,将A上的N歌盘子一个一个搬运到C柱子上,
且一次只能搬运一个,求得搬运多少次,并且C上面盘子要保证与A原来摆放顺序一样(大盘子在下,小盘子在上)
    盘子个数                                搬运次数        搬运方向
    1                                        1                 A->C
    2                                        3                  A->B   A->C  B->C
    3                                        7                  A->C    A->B  C-B   A->C  B->A B->C A->C
    N                                        2^N - 1
*/
/*n为盘子个数,A,B,C分别表示三个柱子*/
void Hanoi(int n, char A, char B, char C)
{
    if (n == 1)
    {
        printf("Move plante %d %c -> %c\n", n, A, C);
    }
    else
    {
        Hanoi(n - 1, A, C, B);
        printf("Move plante %d %c -> %c\n", n, A, C);
        Hanoi(n- 1, B, A, C);
    }
}

/*费氏数列:1 1 2 3 5 8 13 ......
有关系F(m) = F(m-1) + F(m-2) 
*/
/*求F(m)*/
int Fib(int n)
{
    if (n == 0)
    {
        return 1;

    }
    else if (n==1)
    {
        return 1;
    }
    else
    {
        return Fib(n - 1) + Fib(n - 2);
    }
}

/*帕斯卡三角形,m为多项式的(a+b)^m中的m,n为系数所处的位置,返回值为系数值,要满足 m+1 >= n*/
int Paska(int m, int n)
{
    if (n < 0)
    {
        return 0;
    }
    else if (n == 0 )
    {
        return 1;
    }
    else if (0 < n < m )
    {
        return Paska(m - 1, n) + Paska(m - 1, n - 1);
    }
    else if (n == m)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

/*老鼠走迷宫问题:
使用二维阵列表示迷宫
用2表示墙壁,用0表示空白可以行走,用1表示老鼠可以走出的路径
在起始位置有四个方向可以走,上下左右,起始位置肯定空白
*/
#define M  10    //数组列数
int flag = 0;    //是否找到标记
/*查看i行j列处是否为空白,返回1表示成功找到,返回0表示没有找到,找到的路线用1填充*/
int visitArray(int startY, int startX, int endY, int endX, int (*P)[M])
{
        P[startY][startX] = 1;
        if (startY == endY && startX == endX)//如果到出口则找到
        {
            flag = 1;
        }
        if (flag != 1 && P[startY - 1][startX] == 0)//没到到,上路为空白则向上找
            visitArray(startY-1,startX,endY,endX,P);
        if (flag != 1 && P[startY][startX-1] == 0)//没到到,左路为空白则向左找
            visitArray(startY , startX-1, endY, endX, P);
        if (flag != 1 && P[startY +1][startX] == 0)//没到到,下路为空白则向下找
            visitArray(startY +1, startX, endY, endX, P);
        if (flag != 1 && P[startY][startX+1] == 0)//没到到,右路为空白则向右找
            visitArray(startY , startX+1, endY, endX, P);
        return flag;

}

/*50个台阶,每次要么走一步,要么走两步,问有多少次走法
1个台阶     1                     1
2            11 2                 2
3            111 12 21             3
4            1111 22 121 112 211  5

要到达50,从48走2,或从49走1所以有F(N) = F(N-1) + F(N-2)
*/
int stepF(int n)
{
    if (n == 1)
    {
        return 1;
    }
    else if (n == 2)
    {
        return 2;
    }
    else
    {
        return stepF(n - 1) + stepF(n - 2);
    }
}



/*********************************************数据结构算法*********************************************/









/*********************************************文件操作算法*********************************************/
/*从键盘读取字符输出到磁盘文件中,若读取到#,则结束*/
void readFromKey()
{
    char str[20];
    printf("请输入要写入的文件名:");
    scanf("%s", str);
    FILE *F = NULL;
    F = fopen(str, "wt+");
    if (F != NULL)
    {
        int c = getchar();
        while (c != '#')
        {
            fputc(c, F);
            c = getchar();
        }
        fclose(F);
    }
    return;
}
/*从磁盘文件读取内容,然后显示在屏幕上*/
void printFileContent()
{
    char str[20];
    printf("请输入要读取的文件名:");
    scanf("%s", str);
    FILE *F = NULL;
    F = fopen(str, "rt+");
    if (F != NULL)
    {
        int c = EOF;
        while ((c = fgetc(F)) != EOF)
        {
            putchar(c);

        }
        fclose(F);
    }
    return;
}

/*文件复制*/
int copyFile(char *src, char *des)
{
    FILE *SRC = fopen(src, "rt");
    FILE *DES = fopen(des, "wt");
    if (SRC == NULL)
    {
        return -1;
    }
    if (DES == NULL)
    {
        fclose(SRC);
        return -1;
    }
    int c = EOF;
    while ((c = fgetc(SRC)) != EOF)
    {
        fputc(c, DES);
    }
    fclose(SRC);
    fclose(DES);
    return 0;

}
/*将一个长度为L的整形数组a写入到路径path表示的文件中,flag为1表示在文件末尾追加,为0表示从文件头重新写入*/
void writeIntArrayToFile(int a[], int L, char *path, int flag)
{
    char *mode;
    if (flag)
    {
        mode = "ab";
    }
    else
    {
        mode = "wb";
    }
    FILE *F = fopen(path, mode);
    if (F == NULL)
    {
        printf("打开文件失败!");
    }
    else
    {
        int res = 0;
        res = fwrite(a, sizeof(int), L, F);//第一个参数表示写入内存块的首地址,第二个参数表示每个元素大小,
        //第三个参数表示写入元素数量,第四个参数表示要写入的文件,写入成功会返回写入数量

        if (res == L)
        {
            printf("写入成功");
        }
        else
        {
            printf("写入失败");
        }
        fclose(F);
    }
}
/*将路径path表示的文件内容读取到整形数组a中,读取长度为L*/
void readFileToIntArray(int a[], int L, char *path)
{

    FILE *F = fopen(path, "rb");
    if (F == NULL)
    {
        printf("打开文件失败!");
    }
    else
    {
        int res = 0;
        res = fread(a, sizeof(int), L, F);//第一个参数表示写入内存块的首地址,第二个参数表示每个元素大小,
        //第三个参数表示写入元素数量,第四个参数表示要写入的文件,写入成功会返回写入数量

        if (res == L)
        {
            printf("读取成功");
        }
        else
        {
            printf("读取失败");
        }
        fclose(F);
    }
}

/*将一个长度为L的Double数组a写入到路径path表示的文件中,flag为1表示在文件末尾追加,为0表示从文件头重新写入*/
void writeDoubleArrayToFile(double a[], int L, char *path, int flag)
{
    char *mode;
    if (flag)
    {
        mode = "ab";
    }
    else
    {
        mode = "wb";
    }
    FILE *F = fopen(path, mode);
    if (F == NULL)
    {
        printf("打开文件失败!");
    }
    else
    {
        int res = 0;
        res = fwrite(a, sizeof(double), L, F);//第一个参数表示写入内存块的首地址,第二个参数表示每个元素大小,
        //第三个参数表示写入元素数量,第四个参数表示要写入的文件,写入成功会返回写入数量

        if (res == L)
        {
            printf("写入成功");
        }
        else
        {
            printf("写入失败");
        }
        fclose(F);
    }
}
/*将路径path表示的文件内容读取到双精度浮点数组a中,读取长度为L*/
void readFileToDoubleArray(double a[], int L, char *path)
{

    FILE *F = fopen(path, "rb");
    if (F == NULL)
    {
        printf("打开文件失败!");
    }
    else
    {
        int res = 0;
        res = fread(a, sizeof(double), L, F);//第一个参数表示读取内存块的首地址,第二个参数表示每个元素大小,
        //第三个参数表示写入元素数量,第四个参数表示要写入的文件,写入成功会返回写入数量

        if (res == L)
        {
            printf("读取成功");
        }
        else
        {
            printf("读取失败");
        }
        fclose(F);
    }
}

/*将首地址为P的大小为L*SIZE的内存块写入到路径path表示的文件中,内存块的组成小块大小为SIZE,个数为L,flag为1表示在文件末尾追加,为0表示从文件头重新写入*/
void writeMemoryToFile(void *addr, int SIZE,int L, char *path, int flag)
{
    char *mode;
    if (flag)
    {
        mode = "ab";
    }
    else
    {
        mode = "wb";
    }
    FILE *F = fopen(path, mode);
    if (F == NULL)
    {
        printf("打开文件失败!");
    }
    else
    {
        int res = 0;
        res = fwrite(addr, SIZE, L, F);//第一个参数表示写入内存块的首地址,第二个参数表示每个元素大小,
        //第三个参数表示写入元素数量,第四个参数表示要写入的文件,写入成功会返回写入数量

        if (res == L)
        {
            printf("写入成功");
        }
        else
        {
            printf("写入失败");
        }
        fclose(F);
    }
}

/*将路径path表示的文件内容读取到首地址为P的大小为L*SIZE的内存块中,读取长度为L,每小块大小为SIZE字节*/
void readFileToMemory(void *addr, int SIZE, int L, char *path)
{

    FILE *F = fopen(path, "rb");
    if (F == NULL)
    {
        printf("打开文件失败!");
    }
    else
    {
        int res = 0;
        res = fread(addr,SIZE, L, F);//第一个参数表示读取内存块的首地址,第二个参数表示每个元素大小,
        //第三个参数表示写入元素数量,第四个参数表示要写入的文件,写入成功会返回写入数量

        if (res == L)
        {
            printf("读取成功");
        }
        else
        {
            printf("读取失败");
        }
        fclose(F);
    }
}
/*在黑窗口查看一个文本文件内容,使用cmd命令,path为文件路径*/
void lookFileUseType(char *path)
{
    char cmd[20];
    sprintf(cmd, "type %s", path);
    system(cmd);
}
/*在黑窗口查看一个文本文件内容,使用文件指针,path为文件路径*/
void lookFileUsePointer(char *path)
{
    FILE *F = fopen(path, "r");
    if (F == NULL)
    {
        printf("打开文件失败");
    }
    else
    {
        char ch = fgetc(F);
        do
        {
            putchar(ch);
            ch = fgetc(F);
        } while (ch != EOF);
        fclose(F);
    }
}
/*测量一个文件长度,查看文件大小,字节数表示,返回-1表示失败*/
long measureFileSize(char *path)
{
    FILE *F = fopen(path, "rb");
    if (F == NULL)
    {
        return  -1;
    }
    else
    {
        fseek(F, 0, SEEK_END);//将文件指针移动到文件末尾
        long length = ftell(F);//计算文件指针到文件开头的字节数,即就是文件大小
        fclose(F);
        return length;
    }
}
/*清空一个文件内容,任何格式磁盘文件文件大小变为0,但是不删除该文件*/
void clearFileContent(char *path)
{
    FILE *F = fopen(path, "wb");
    char s = '\0';
    if (F == NULL)
    {
        printf("打开文件失败");
    }
    else
    {
        fwrite(&s, 1, 0, F);
        fclose(F);
    }
}

/*将一个长度为L的字符型数组a写入到路径path表示的文件中,flag为1表示在文件末尾追加,为0表示从文件头重新写入*/
void writeCharArrayToFile(char a[], int L, char *path, int flag)
{
    char *mode;
    if (flag)
    {
        mode = "ab";
    }
    else
    {
        mode = "wb";
    }
    FILE *F = fopen(path, mode);
    if (F == NULL)
    {
        printf("打开文件失败!");
    }
    else
    {
        int res = 0;
        res = fwrite(a, sizeof(char), L, F);//第一个参数表示写入内存块的首地址,第二个参数表示每个元素大小,
        //第三个参数表示写入元素数量,第四个参数表示要写入的文件,写入成功会返回写入数量

        if (res == L)
        {
            printf("写入成功");
        }
        else
        {
            printf("写入失败");
        }
        fclose(F);
    }
}
/*将路径path表示的文件内容读取到字符型数组a中,读取长度为L*/
void readFileToCharArray(char a[], int L, char *path)
{

    FILE *F = fopen(path, "rb");
    if (F == NULL)
    {
        printf("打开文件失败!");
    }
    else
    {
        int res = 0;
        res = fread(a, sizeof(char), L, F);//第一个参数表示写入内存块的首地址,第二个参数表示每个元素大小,
        //第三个参数表示写入元素数量,第四个参数表示要写入的文件,写入成功会返回写入数量

        if (res == L)
        {
            printf("读取成功");
        }
        else
        {
            printf("读取失败");
        }
        fclose(F);
    }
}
/*修改路径为path的文件,将它距离文件开头pos字节数的位置的一个字节二进制数据修改为c*/
void changeFileByte(char *path, int pos, char c)
{
    FILE *F = fopen(path, "rb+");
    if (F == NULL)
    {
        printf("打开文件失败");
    }
    else
    {
        fseek(F, pos, SEEK_SET);
        fwrite(&c, 1, 1, F);
        fclose(F);
    }
}
/*修改路径为path的文件,将它距离文件开头pos字节数的位置的L个字节二进制数据修改为*c*/
void changeFileBytes(char *path, int pos, int L, char *c)
{
    FILE *F = fopen(path, "rb+");
    if (F == NULL)
    {
        printf("打开文件失败");
    }
    else
    {
        fseek(F, pos, SEEK_SET);
        fwrite(c, 1, L, F);
        fclose(F);
    }
}
/*合并两个文件,使用二进制形式,将一个文件rear添加到另一个文件front的末尾,flag=1表示合并后删除read文件,flag=0表示不删除*/
void combineTwoFileBin(char *front, char *rear, int flag)
{
    FILE *F = fopen(front, "ab");
    if (F == NULL)
    {
        printf("打开文件FRONT失败");
    }
    else
    {
        FILE *R = fopen(rear, "rb");
        if (R == NULL)
        {
            printf("打开文件REAR失败");
            fclose(F);
        }
        else
        {
            char s;
            while (!feof(R))
            {
                fread(&s, 1, 1, R);
                fwrite(&s, 1, 1, F);
            }
            fclose(F);
            fclose(R);

            if (flag)
            {
                remove(rear);
            }

        }
    }
}
/*根据指定路径创建一个目录*/
void makeDir(char *path)
{
    char md[100];
    sprintf(md, "mkdir %s", path);
    system(md);
}
/*统计英文文档大写字母个数,小写字母个数,数字字符数,统计换行符个数,空格字符个数,逗号字符数,其他字符数,按顺序存放在一个长度为7count数组中,path为文件路径 ,L必须为7*/
void statEnglishFile(char *path, int count[], int L)
{
    if (L != 7)
        return;
    for (size_t i = 0; i < 7; i++)
    {
        count[i] = 0;
    }

    FILE *F = fopen(path, "r");
    if (F == NULL)
    {
        printf("打开文件失败");
    }
    else
    {
        char ch;
        while ((ch = fgetc(F)) != EOF)
        {
            if (ch > 'A' && ch < 'Z')
            {
                count[0]++;
            }
            else if (ch > 'a' && ch < 'z')
            {
                count[1]++;
            }
            else if (ch > '0' && ch < '9')
            {
                count[2]++;
            }
            else if (ch == '\n')
            {
                count[3]++;
            }
            else if (ch == ' ')
            {
                count[4]++;
            }
            else if (ch == ',')
            {
                count[5]++;
            }
            else
            {
                count[6]++;
            }
        }

        fclose(F);
    }

}
/*统计双字节字符*/
int statFileDoubleChar(char *path)
{
    FILE *F = fopen(path, "r");
    int numc = 0;//双字节字符
    if (F == NULL)
    {
        printf("文件打开失败");
        perror("失败原因:");
    }
    else
    {
        int ch;//必须用int,汉字占两个字节,char装不下,int占四个字节
        
        int nume = 0;//英文字符
        int numn = 0;//数字字数

        while ((ch = fgetc(F)) != EOF)
        {
            if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'))
            {
                nume++;
            }
            else if (ch >= '0' && ch <= '9')
            {
                numn++;
            }
            else if (ch > 128)//判定ch为双字节字符
            {
                ch = fgetc(F);//在读取一个
                numc++;
            }
            else
            {

            }
        }
        fclose(F);
        
    }
    return numc;
}
/*统计汉字字符,汉字采用GBK编码*/
int statFileChineseChar(char *path)
{
    FILE *F = fopen(path, "r");
    int numc = 0;//汉字字符
    if (F == NULL)
    {
        printf("文件打开失败");
        perror("失败原因:");
    }
    else
    {
        int ch;//必须用int,汉字占两个字节,char装不下,int占四个字节
    
        int nume = 0;//英文字符
        int numn = 0;//数字字数

        while ((ch = fgetc(F)) != EOF)
        {
            if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'))
            {
                nume++;
            }
            else if (ch >= '0' && ch <= '9')
            {
                numn++;
            }
            else if (ch > 128)//判定ch为双字节字符
            {
                int nextch = fgetc(F);//再读取一个    
                if ((ch >= 0x81 && ch <= 0xA0) && ((nextch >= 0x40 && nextch <= 0x7E) || (nextch >= 0x80 && nextch <= 0xFE)))
                {
                    numc++;
                }
                else if ((ch >= 0xB0 && ch <= 0xD6) && ((nextch >= 0x40 && nextch <= 0x7E) || (nextch >= 0x80 && nextch <= 0xFE)))
                {
                    numc++;
                }
                else if ((ch >= 0xD8 && ch <= 0xF7) && ((nextch >= 0x40 && nextch <= 0x7E) || (nextch >= 0x80 && nextch <= 0xFE)))
                {
                    numc++;
                }
                else if ((ch >= 0xAA && ch <= 0xAF) && ((nextch >= 0x40 && nextch <= 0x7E) || (nextch >= 0x80 && nextch <= 0xA0)))
                {
                    numc++;
                }
                else if ((ch >= 0xF8 && ch <= 0xFE) && ((nextch >= 0x40 && nextch <= 0x7E) || (nextch >= 0x80 && nextch <= 0xA0)))
                {
                    numc++;
                }
                else if ((ch == 0xD7) && ((nextch >= 0x40 && nextch <= 0x7E) || (nextch >= 0x80 && nextch <= 0xF9)))
                {
                    numc++;
                }

            }
            else
            {

            }
        }
        fclose(F);
    
    }
    return numc;
}
/*windows下在路径searchpath下搜索文件名前缀为frontname后缀为rearname的文件,如果两者有一个为*代表通配符,统配任何哪种格式的文件,outputfile为存储找到的文件路径信息的文件*/
void  searchFileInWindows(char *searchpath, char *frontname, char *rearname, char *outputfile)
{
    char cmd[512];
    sprintf(cmd, "for /r \"%s\" %%i in (%s.%s) do @echo %%i >> \"%s\"", searchpath, frontname, rearname, outputfile);
    system(cmd);
    char show[100];
    sprintf(show, "type %s", outputfile);
    system(show);


}
/*linux下在路径searchpath下搜索文件名前缀为frontname后缀为rearname的文件,如果两者有一个为*代表通配符,统配任何哪种格式的文件,outputfile为存储找到的文件路径信息的文件*/
void searchFileInLinux(char *searchpath, char *frontname, char *rearname, char *outputfile)
{
    char cmd[512];
    sprintf(cmd, "find %s -name %s.%s >> %s ", searchpath, frontname, rearname, outputfile);
    system(cmd);


}

/***************文件加密*****************/
/*移位加密文本文件path为文件路径,endpath为加密后的密文路径,key为秘钥*/
void encryptedFileUseMoveBit(char *path, char *endpath, int key)
{
    FILE *F = fopen(path, "rb");
    FILE *P = fopen(endpath, "wb");
    if (F == NULL || P == NULL)
    {
        printf("加密失败");
    }
    else
    {
        char ch;
        while ((ch = fgetc(F)) != EOF)
        {

            ch = ch + key;
            fputc(ch, P);
        }

        fclose(F);
        fclose(P);
    }
}

/*移位解密文本文件path为文件路径,endpath为解密后的明文路径,key为秘钥*/
void decryptedFileUseMoveBit(char *path, char *endpath, int key)
{

    FILE *F = fopen(path, "rb");
    FILE *P = fopen(endpath, "wb");
    if (F == NULL || P == NULL)
    {
        printf("加密失败");
    }
    else
    {
        char ch;
        while ((ch = fgetc(F)) != EOF)
        {

            ch = ch - key;
            fputc(ch, P);
        }
        fclose(F);
        fclose(P);
    }
}

/*异或加密文件path为文件路径,endpath为加密后的密文路径,key为秘钥*/
void encryptedFileUseXor(char *path, char *endpath, int key)
{
    FILE *F = fopen(path, "rb");
    FILE *P = fopen(endpath, "wb");
    if (F == NULL || P == NULL)
    {
        printf("加密失败");
    }
    else
    {
        char ch;
        while ((ch = fgetc(F)) != EOF)
        {

            ch = ch ^ key;
            fputc(ch, P);
        }

        fclose(F);
        fclose(P);
    }
}

/*异或解密文件path为文件路径,endpath为解密后的明文路径,key为秘钥*/
void decryptedFileUseXor(char *path, char *endpath, int key)
{

    FILE *F = fopen(path, "rb");
    FILE *P = fopen(endpath, "wb");
    if (F == NULL || P == NULL)
    {
        printf("加密失败");
    }
    else
    {
        char ch;
        while ((ch = fgetc(F)) != EOF)
        {

            ch = ch ^ key;
            fputc(ch, P);
        }
        fclose(F);
        fclose(P);
    }
}

/*字符串加密文件path为文件路径,endpath为加密后的密文路径,key为秘钥,L为长度*/
void encryptedFileUseChars(char *path, char *endpath, char key[], int L)
{
    FILE *F = fopen(path, "rb");
    FILE *P = fopen(endpath, "wb");
    if (F == NULL || P == NULL)
    {
        printf("加密失败");
    }
    else
    {
        char ch;
        for (int i = 0; i < L;)
        {
            if ((ch = fgetc(F)) != EOF)
            {

                ch = ch + key[i];
                fputc(ch, P);
                i++;
                if (i == L)
                    i = 0;
            }
            else
            {
                break;
            }

        }


        fclose(F);
        fclose(P);
    }
}

/*字符串解密文件path为文件路径,endpath为解密后的明文路径,key为秘钥,L为长度*/
void decryptedFileUseChars(char *path, char *endpath, char key[], int L)
{

    FILE *F = fopen(path, "rb");
    FILE *P = fopen(endpath, "wb");
    if (F == NULL || P == NULL)
    {
        printf("加密失败");
    }
    else
    {
        char ch;
        for (int i = 0; i < L;)
        {
            if ((ch = fgetc(F)) != EOF)
            {

                ch = ch - key[i];
                fputc(ch, P);
                i++;
                if (i == L)
                    i = 0;
            }
            else
            {
                break;
            }

        }
        fclose(F);
        fclose(P);
    }
}
/*文件分割,path为要分割的文件路径name为文件名,count为分割数量,savepath为保存路径,返回-1表示分割失败,0表示成功*/
int splitFile(char *path, int count, char *savepath, char *savename)
{
    FILE *F = fopen(path, "rb");
    if (F == NULL)
    {
        return  -1;
    }
    else
    {
        fseek(F, 0, SEEK_END);//将文件指针移动到文件末尾
        int length = ftell(F);//计算文件指针到文件开头的字节数,即就是文件大小
        int yushu = length % count;//余数
        int size = length / count; //前面count-1份每一分大小为size,最后一份为size + yushu
        for (int i = 1; i <= count; i++)
        {
            char savefile[100];
            sprintf(savefile, "%s%d%s", savepath, i, savename);
            printf("%s", savefile);
            FILE *P = fopen(savefile, "wb");
            if (P == NULL)
            {
                fclose(F);
                return -1;
            }
            else
            {
                fseek(F, (i - 1)*size, SEEK_SET);
                if (i == count)
                {
                    for (int j = 0; j <= size + yushu; j++)
                    {
                        int c = fgetc(F);
                        fputc(c, P);
                    }
                }
                else
                {
                    for (int j = 0; j < size; j++)
                    {
                        int c = fgetc(F);
                        fputc(c, P);
                    }
                }


            }
            fclose(P);
        }
        fclose(F);
        return 0;
    }

}
/*合并文件,将文件list中每一行指定的文件按行顺序合并为一个大文件bigfile返回-1表示分割失败,0表示成功*/
int mergeFile(char *list, int count, char *bigfile)
{
    FILE *F = fopen(list, "r");
    FILE *BF = fopen(bigfile, "wb");
    if (F == NULL || BF == NULL)
    {
        printf("打开文件失败");
        return -1;
    }
    else
    {

        for (int i = 0; i < count; i++)
        {
            char str[200];
            fgets(str, 200, F);//每次读取一行字符串,读到末尾为0
            printf("%s", str);
            int len = strlen(str);
            str[len - 1] = '\0';
            printf("%s", str);
            FILE *P = fopen(str, "rb");
            if (P == NULL)
            {
                printf("打开文件失败");
                fclose(F);
                fclose(BF);
                return -1;
            }
            else
            {
                int c = fgetc(P);
                while (c != EOF)
                {

                    fputc(c, BF);
                    c = fgetc(P);
                }
            }
            fclose(P);


        }



    }
    fclose(F);
    fclose(BF);
    return 0;
}

/*写入一行文本到文件将一行字符串str写入文件path中,使用系统命令,mode表示模式,非0表示追加模式,0表示重新从头写入*/
void writeStringToFile(char *str, char *path, int mode)
{
    char cmd[100];
    if (mode == 0)
    {
        sprintf(cmd, "echo %s > %s", str, path);
    }
    else
    {
        sprintf(cmd, "echo %s >> %s", str, path);
    }

    system(cmd);
}
/*写入一行文本到文件将一行字符串str写入文件path中,使用文件指针,mode表示模式,非0表示追加模式,0表示重新从头写入*/
void writeStringToFileUsePointer(char *str, char *path, int mode)
{
    FILE *F;
    if (mode == 0)
    {
        F = fopen(path, "wb");
    }
    else
    {
        F = fopen(path, "ab");
    }
    if (F == NULL)
    {
        printf("文件打开失败");
        return ;
    }
    else
    {
        int len = strlen(str);
        for (int i = 0; i < len; i++)
        {
            fputc(str[i], F);
        }
        fputc('\r', F);
        fputc('\n', F);
    }
    fclose(F);


}

/***********************大文本文件处理********************/
/* 下面这些方法可以处理大文件*/





/*打印path这个文本文件内容*/
void printfFileContent(char *path)
{
    FILE *F = fopen(path, "r");
    if (F == NULL)
    {
        printf("打开文件失败");
        return;
    }
    else
    {
        char str[100];
        while (fgets(str, 100, F))//没有到达文件末尾就一直读
        {
            printf("%s", str);
        }
    }
    fclose(F);

}
/*文本文件查询,在文件path中搜索字符串str,如果找到返回1,没找到返回0,找到后将所在行号和内容打印出来*/
int searchStringInFile(char *substr, char *path)
{
    FILE *F = fopen(path, "r");
    if (F == NULL)
    {
        printf("打开文件失败");
        return 0;
    }
    else
    {
        char str[100];
        int num = 0;//记录行号,从第0行开始
        while (fgets(str, 100, F))//读取一行没有到达文件末尾就一直读
        {
            printf("%s", str);
            num++;
            char *p = strstr(str, substr);
            if (p != NULL)//找到
            {
                printf("找到要查找的内容:%d:%s", num, str);


            }
            else
            {
                printf("%s", str);
            }

        }
    }
    fclose(F);
    return 1;
}

/*文本文件删除,在文件path中删除字符串substr,temp为临时文件,如果成功返回1,没成功返回0,将删除后的文件打印出来*/
int deleteStringFromFile(char *substr, char *path, char *temp)
{
    FILE *F = fopen(path, "r");
    FILE *P = fopen(temp, "w");
    if (F == NULL || P == NULL)
    {
        printf("打开文件失败");
        return 0;
    }
    else
    {
        char str[100];
        while (fgets(str, 100, F))//读取一行没有到达文件末尾就一直读
        {
            //printf("%s", str);

            char *p = strstr(str, substr);
            if (p != NULL)//找到就不写入temp文件中
            {
                //printf("找到要查找的内容:%d:%s",str);
                deleteStringInString(substr, str);
                fputs(str, P);

            }
            else
            {
                printf("%s", str);
                fputs(str, P);
            }

        }
    }
    fclose(F);
    fclose(P);
    remove(path);//删除原来的文件
    rename(temp, path);//将文件名改为原来的文件名
    return 1;
}

/*文本文件修改,在文件path中使用newstr替换字符串substr,temp为临时文件,如果成功返回1,没成功返回0,*/
int changeStringInFile(char *newstr, char *substr, char *path, char *temp)
{
    FILE *F = fopen(path, "r");
    FILE *P = fopen(temp, "w");
    if (F == NULL || P == NULL)
    {
        printf("打开文件失败");
        return 0;
    }
    else
    {
        char str[100];
        while (fgets(str, 100, F))//读取一行没有到达文件末尾就一直读
        {
            //printf("%s", str);

            char *p = strstr(str, substr);
            if (p != NULL)//找到就不写入temp文件中
            {
                //printf("找到要查找的内容:%d:%s",str);
                changeStringInString(newstr, substr, str);
                fputs(str, P);

            }
            else
            {
                printf("%s", str);
                fputs(str, P);
            }

        }
    }
    fclose(F);
    fclose(P);
    remove(path);//删除原来的文件
    rename(temp, path);//将文件名改为原来的文件名
    return 1;
}

/*文本文件增加,在文件path中将newstr添加在字符串substr的前面,temp为临时文件,如果成功返回1,没成功返回0,*/
int addStringToFile(char *newstr, char *substr, char *path, char *temp)
{
    FILE *F = fopen(path, "r");
    FILE *P = fopen(temp, "w");
    if (F == NULL || P == NULL)
    {
        printf("打开文件失败");
        return 0;
    }
    else
    {
        char str[200];
        while (fgets(str, 200, F))//读取一行没有到达文件末尾就一直读
        {
            //printf("%s", str);

            char *p = strstr(str, substr);
            if (p != NULL)//找到就不写入temp文件中
            {
                //printf("找到要查找的内容:%d:%s",str);
                addStringInString(newstr, substr, str);
                fputs(str, P);

            }
            else
            {
                printf("%s", str);
                fputs(str, P);
            }

        }
    }
    fclose(F);
    fclose(P);
    remove(path);//删除原来的文件
    rename(temp, path);//将文件名改为原来的文件名
    return 1;
}

/*在文件path中搜索字符串str所在行然后打印出来*/
void printStringInLine(char *substr, char *path)
{
    FILE *F = fopen(path, "r");
    if (F == NULL)
    {
        printf("打开文件失败");
        return;
    }
    else
    {
        char str[100];
        while (fgets(str, 100, F))//读取一行没有到达文件末尾就一直读
        {

            char *p = strstr(str, substr);
            if (p != NULL)//找到
            {
                puts(str);
            }

        }
    }
    fclose(F);
}

/*在文件path中读取第n行然后打印出来,*/
void printnLineString(int n, char *path)
{
    FILE *F = fopen(path, "r");
    if (F == NULL)
    {
        printf("打开文件失败");
        return;
    }
    else
    {
        char str[100];
        int num = 0;
        while (fgets(str, 100, F))//读取一行没有到达文件末尾就一直读
        {

            num++;
            if (num == n)//找到
            {
                puts(str);
            }

        }
    }
    fclose(F);
}

 3.测试部分本人用于时间关系只测试了一小部分算法,大家有时间的话可以帮忙测试下,共同进步

#include
#include
#include "algorithm.h"


void main()
{
    //Hanoi(3, 'A', 'B', 'C');
    //printf("%d", Fib(8));
    //printf("%d",Paska(4,2));
    /*获取N以下的质数,并按从小到大的顺序存放到数组P中,L为数组最大长度*/
    int factor[100];
    int prime[100];
    int mm;
    int nn;
    
    //getPrimeNumTable(100, factor, &mm);
    //for (size_t i = 0; i < mm; i++)
    //{
    //    printf("%d\n", factor[i]);
    //}
    /*求一个数的所有质因数,并按从小到大的顺序存放到数组P中,L为存放质因数个数地址,*/
    getFactor(20, factor, prime, &mm,&nn );
    printf("%d\n",mm);
    for (int i = 0; i < mm; i++)
    {
        printf("%d\n", factor[i]);
    }
    system("pause");
}

4.c语言是一门运行高效开发低效的语言,但是也是最强大,最灵活的高级语言,将像一杯美酒,时间久了才会香,希望大家学好c语言。

你可能感兴趣的:(cobol,relativelayout,mooc,memcached,哈希算法)