c语言-自己写的库

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

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

#ifndef _INC_ALGORITHM
#define _INC_ALGORITHM
#endif
 
#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
#include<math.h>
#include<time.h>
#include<string.h>
 
/*
本算法库封装了大多数常用算法，一部分摘取书籍，大部分为自己动手编写，
大部分经过测试，可以直接使用，如有错误，欢迎指正，使用请尊重作者的成果，注明出处。
注意：除了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 ;
        }
 
    }
    return -;
}
 
/********************************************排序查询类算法********************************************/
/*二分查找法，上，中，下，前提数组必须有序找到返回0否则返回-1*/
int binerySearch(char **p, int count, char *des)
{
    int low = ;
    int high = count;
    while (low < high)
    {
        int mid = (low + count) / ;
        if (strcmp(des, p[mid]) < )
        {
            high = mid - ;
        }
        else if (strcmp(des, p[mid]) > )
        {
            low = mid + ;
        }
        else
        {
            printf("找到了");
            return ;
        }
    }
    return -;
 
}
 
/********************************************数学类算法********************************************/
/*乘法表打印方形*/
void print9X9Table()
{
 
    for (int i = ; i <= ; i++)
    {
 
        for (int j = ; j <= ; j++)
        {
            printf("%d X %d = %d\t", i, j, i*j);
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}
 
/*乘法表打印反对角线以下*/
void print9X9Table1()
{
    for (int i = ; i <= ; i++)
    {
 
        for (int j = ; j <= ; j++)
        {
            if (i >= j)
                printf("%d X %d = %d\t", i, j, i*j);
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}
 
/*乘法表打印反对角线以上*/
void print9X9Table2()
{
    for (int i = ; i <= ; i++)
    {
 
        for (int j = ; j <= ; 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 = ; i <= ; i++)
    {
 
        for (int j = ; j <= ; j++)
        {
            if (i + j <= )
            {
                printf("%d X %d = %d\t", i, j, i*j);
            }
 
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}
 
/*乘法表打印反对角线以下*/
void print9X9Table4()
{
    for (int i = ; i <= ; i++)
    {
 
        for (int j = ; j <= ; j++)
        {
            if (i + j >= )
            {
                printf("%d X %d = %d\t", i, j, i*j);
            }
            else
            {
                printf("         \t");
            }
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}
 
/*乘法表打印反对角线上的*/
void print9X9Table5()
{
    for (int i = ; i <= ; i++)
    {
 
        for (int j = ; j <= ; 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 = ; i <= ; i++)
    {
 
        for (int j = ; j <= ; j++)
        {
            if (i + j == )
            {
                printf("%d X %d = %d\t", i, j, i*j);
            }
            else
            {
                printf("         \t");
            }
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}
 
/*乘法表打印两条对角线上部的*/
void print9X9TableUp()
{
    printf("上部区域：\n");
    for (int i = ; i <= ; i++)
    {
 
        for (int j = ; j <= ; j++)
        {
            if (i < j && (i + j < ))
            {
                printf("%d X %d = %d\t", i, j, i*j);
            }
            else
            {
                printf("         \t");
            }
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}
/*乘法表打印两条对角线下部的*/
void print9X9TableDown()
{
    printf("下部区域：\n");
    for (int i = ; i <= ; i++)
    {
 
        for (int j = ; j <= ; j++)
        {
            if (i > j && (i + j > ))
            {
                printf("%d X %d = %d\t", i, j, i*j);
            }
            else
            {
                printf("         \t");
            }
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}
/*乘法表打印两条对角线左边的*/
void print9X9TableLeft()
{
    printf("左部区域：\n");
    for (int i = ; i <= ; i++)
    {
 
        for (int j = ; j <= ; j++)
        {
            if (i > j && (i + j < ))
            {
                printf("%d X %d = %d\t", i, j, i*j);
            }
            else
            {
                printf("         \t");
            }
        }
        printf("\n\n");
    }
    printf("————————————————————————————————————");
}
/*乘法表打印两条对角线右边的的*/
void print9X9TableRight()
{
    printf("右部区域：\n");
    for (int i = ; i <= ; i++)
    {
 
        for (int j = ; j <= ; j++)
        {
            if (i < j && (i + j > ))
            {
                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 = ;
    int num = ;
    for (; i <= N; i++)
    {
        num *= ;
    }
    return num;
}
/*求2的一次方到2的N次方的和*/
int S2n(int N)
{
    int i = ;
    int num = ;
    for (; i <= N; i++)
    {
        num += T2n(i);
    }
    return num;
}
/*求两个数的最大公因数 a > b*/
int maxCommonFactor(int a, int b)
{
    int r = ;
    while ( b != )
    {
        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 = ;
    int m = ;
    for (int j = ; j <= N; j++)
    {
        T = sqrt(j);
        int i;
        for (i = ; i <= T; i++)
        {
            if (j % i ==  )
            {
                break;
            }
        }
        if (i > T)
        {
            P[m++] = j;
        }
        if (m > L - )
            return;
    }
    *L = m;
 
}
/*求一个数的所有质因数,并按从小到大的顺序存放到数组P中,L为存放质因数个数地址,F为中间获取质数的数组表，T为存储质数数组长度的变量*/
int getFactor(int m,int *P,int *F,int *L,int *T)
{
 
    int n = ;
 
    getPrimeNumTable(m, F, T);
 
    for (int i = ; i < *T; i++)
    {
        if (m % F[i] == )
        {
            P[n++] = F[i];
 
        }
    }
    *L= n;
    return n;
}
 
/*使用递归10进制转0进制打印*/
void  PrintBin(int n)
{
    if (n == )
    {
        return;
    }
    else
    {
        int x = n % ;//只要将2改为8，或16就可以转换为8进制或16进制
        n /= ;
        //printf("%d", x);放在递归调用之前，则会先打印，二进制反序
        PrintBin(n);
        printf("%d", x);//放在递归调用之后，则会最后执行打印
    }
}
/*穷举法求13X+12Y=100的整数解,X = （100 - 12Y）/ 13 为整数*/
void getEquationValue()
{
    for (int i = ;; i++)
    {
        if (( -  * i) %  == )
        {
            printf("整数解为：X = %d，Y = %d\n", ( -  * i) / , i);
            break;
        }
    }
    system("pause");
}
 
/*二进制整数转十进制，接受一个二进制字符串，将它转为10进制整数数*/
int BinToDec(char *bin)
{
    char *p;
    int len = ;//统计二进制位数
    int num = ;
 
    for (p = bin; *p != '\0'; p++)
    {
        if ((*p) != '' && (*p) != '')
        {
            printf("%d", *p);
            printf("您输入的二进制整数不合法");
            return ;
        }
        len++;
        if (len > )
        {
            printf("您输入的位数过多");
            return ;
        }
        num = num *  + (*p - );
    }
    return num;
 
}
/*十进制整数转二进制字符串*/
char *DecToBin(int num, char *s)
{
    char *p;
    char *q;
    p = s;
    char c;
    while (num >= )
    {
        *p = num %  + '';
        //printf("%c", *p);
        num = num / ;
        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 = ;
    while (tem != )
    {
        m = m *  + tem % ;
 
        tem /= ;
 
    }
    return m;
}
/*取出一个整数的每个位，存入到一个数组中，第一个为个位，依次类推*/
int GetIntBit(int num, int bit[])
{
    int tem = num;
    int i = ;
 
    while (tem != )
    {
        bit[i] = tem % ;
        i++;
        tem /= ;
 
    }
    return i;
}
/*产生一个N之内的随机数*/
int  RandomNumber(int N)
{
    //以时间为种子创建随机数
    time_t tm = ;
    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 = ; i < n; i++)
    {
        int temp = ;
        for (int j = ; j < i; j++)
        {
            temp *= ;
        }
        bit[i] = num / temp % ;
    }
 
    int tcf = ;
    for (int i = ; i < n; i++)
    {
        tcf += bit[i] * bit[i] * bit[i];
    }
    if (num == tcf)
    {
        printf("%d\n", num);
        return ;
    }
    return -;
 
}
 
/*生成n个小于m的随机数，并将生成的随机数存放到数组p中*/
void randNumber(int *p, int n, int m)
{
    time_t tm = ;//时间数据类型
    unsigned int ctime = (unsigned int)tm;
    srand(ctime);//以时间做种子生成随机数
    for (int i = ; i < n; i++)
    {
        p[i] = rand() % m;
    }
}
 
/********************************************逻辑类算法****************************************/
/*置位int数num的第N个位*/
void setInt(int *num, int N)
{
    if (N > )
    {
        printf("超出置位范围0-31");
        return;
    }
    *num |= ( << N);
}
/*清零int数num的第N个位*/
void clearInt(int *num, int N)
{
    if (N > )
    {
        printf("超出置位范围0-31");
        return;
    }
    *num &= ~( << N);
}
/*统计num中是1的位数，返回位数*/
int statIntOne(int num)
{
    int count = ;
 
    for (int i = ; i < ; i++)
    {
        int t = num & ;
        if (t == )
            count++;
 
        num = num >> ;
    }
    return count;
 
}
/*统计num中是0的位数，返回位数*/
int statIntZero(int num)
{
    int count = ;
 
    for (int i = ; i < ; i++)
    {
        int t = num & ;
        if (t == )
            count++;
 
        num = num >> ;
    }
    return count;
 
}
/*翻转一个int数，即高位和低位互换 0位和31位互换，1位和30维护换返回位数*/
int reverseInt(int *num)
{
 
    int tem = *num;
    for (int i = ; i < ; i++)
    {
        int t = tem & ;//1.取出每一位的值，
 
        //2.将第0位的值置给31，第一位的值置给30
        if (t == )//
        {
            setInt(num,  - i);
            //printf("%d\n", *num);
        }
        else
        {
 
            clearInt(num,  - i);
            //printf("%d\n", *num);
        }
        tem = tem >> ;
 
    }
 
    return *num;
 
}
/*以二进制形式打印一个整数*/
void printfIntBinary(int num)
{
    reverseInt(&num);
    for (size_t i = ; i < ; i++)
    {
 
        int t = num & ;
        printf("%d", t);
        num = num >> ;
    }
}
/*循环左移位的实现num左移N位*/
int moveToLeft(int num, int N)
{
    for (int i = ; i < N; i++)
    {
        int t = num & ( << );//1.取出最高位的值，
        num = num << ;//左移一位
        //2.先将第0位的值置给31，
        if (t != )//
        {
            setInt(&num, );
            //printf("%d\n", *num);
        }
        else
        {
 
            clearInt(&num, );
            //printf("%d\n", *num);
        }
    }
    return num;
 
}
/*循环右移位的实现num右移N位*/
int moveToRight(int num, int N)
{
    for (int i = ; i < N; i++)
    {
        int t = num & ;//1.取出每一位的值，
        num = num >> ;
        //2.先将第0位的值置给31，
        if (t == )//
        {
            setInt(&num, );
            //printf("%d\n", *num);
        }
        else
        {
 
            clearInt(&num, );
            //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 > )
    {
        printf("超出置位范围0-31");
        return -;
    }
    int t = (num  & ( << m));
    if (t == )
    {
        return ;
    }
    else
    {
        return ;
    }
 
}
/*打印一个int数在内存中的二进制码,正数就是它的原码，负数就是它的补码*/
void printfBinCode(int num)
{
    int m = ;
    while (m >= )
    {
        if (getIntBit(num, m))
        {
            printf("");
        }
        else
        {
            printf("");
        }
        m--;
    }
}
/*输出一个int数的原码，正数就是它的二进制码，负数就是对应二进制码(反码)的原码*/
void printfSrcCode(int num)
{
    if (num >= )
    {
        printfBinCode(num);
    }
    else
    {
        num = num - ;
        num = ~num;
        setInt(&num, );
        printfBinCode(num);
 
    }
}
 
/*打印一个unsigned char 类型的二进制码*/
void printfCharCode(unsigned char s)
{
    int m = ;
    while (m >= )
    {
        if (getIntBit(s, m))
        {
            printf("");
        }
        else
        {
            printf("");
        }
        m--;
    }
}
/*打印一个浮点数的二进制码*/
void printfFloatCode(float f)
{
    unsigned char *p;
    p = (unsigned char *)&f;
    int N = ;
    while (N >= )
    {
        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 -  * a*c;
        double n = - * b /  / a;
        if (m == )
        {
            printf("有两个相等的实数根：x1 = x2 = %lf", n);
        }
        else if (m > )
        {
            printf("有两个不相等的实数根：x1 = %lf，x2 = %lf", n - sqrt(m) /  / a, n + sqrt(m) /  / a);
        }
        else
        {
            printf("有两个不相等的虚数根：x1 = %lf+%lfi，x2 = %lf-%lfi", n, sqrt(-m) /  / a, n, sqrt(-m) /  / 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, , , , );//鼠标左键按下
    mouse_event(MOUSEEVENTF_LEFTUP, , , , );//鼠标左键抬起，一组按下和抬起构成一次点击
}
/*模拟鼠标双击*/
void DoubleClick()
{
    mouse_event(MOUSEEVENTF_LEFTDOWN, , , , );//鼠标左键按下
    mouse_event(MOUSEEVENTF_LEFTUP, , , , );//鼠标左键抬起，一组按下和抬起构成一次点击
    mouse_event(MOUSEEVENTF_LEFTDOWN, , , , );//鼠标左键按下
    mouse_event(MOUSEEVENTF_LEFTUP, , , , );//鼠标左键抬起，一组按下和抬起构成一次点击
}
/*模拟鼠标右击*/
void RightClick()
{
    mouse_event(MOUSEEVENTF_RIGHTDOWN, , , , );//鼠标左键按下
    mouse_event(MOUSEEVENTF_RIGHTUP, , , , );//鼠标左键抬起，一组按下和抬起构成一次点击
 
}
/*Left mouse button键的模拟*/
void LeftMouseButton()
{
    keybd_event(0x01, , , );//键盘模拟
    keybd_event(0x01, , , );//键盘模拟
}
 
/*Right mouse button键的模拟*/
void RightMouseButton()
{
    keybd_event(0x01, , , );//键盘模拟
    keybd_event(0x01, , , );//键盘模拟
}
/*Control-break processing键的模拟*/
void Cancle()
{
    keybd_event(0x03, , , );//键盘模拟
    keybd_event(0x03, , , );//键盘模拟
}
/*鼠标中键的模拟*/
void MiddleButton()
{
    keybd_event(0x04, , , );//键盘模拟
    keybd_event(0x04, , , );//键盘模拟
}
/*backspace键的模拟*/
void Backspace()
{
    keybd_event(0x08, , , );
    keybd_event(0x08, , , );
}
/*TAB key键的模拟*/
void Tab()
{
    keybd_event(0x09, , , );
    keybd_event(0x09, , , );
}
/*CLEAR key键的模拟*/
void ClearKey()
{
    keybd_event(0x0C, , , );
    keybd_event(0x0C, , , );
}
/*ENTER回车键 key键的模拟*/
void Enter()
{
    keybd_event(0x0D, , , );
    keybd_event(0x0D, , , );
}
/*SHIFT key键的模拟*/
void Shift()
{
    keybd_event(0x10, , , );
    keybd_event(0x10, , , );
}
/*CTRL key键的模拟*/
void Ctrl()
{
    keybd_event(0x11, , , );
    keybd_event(0x11, , , );
}
/*ALT key键的模拟*/
void Alt()
{
    keybd_event(0x12, , , );
    keybd_event(0x12, , , );
}
/*PAUSE key键的模拟*/
void Pause()
{
    keybd_event(0x13, , , );
    keybd_event(0x13, , , );
}
 
/*CAPS LOCK key键的模拟*/
void CapsLock()
{
    keybd_event(0x14, , , );
    keybd_event(0x14, , , );
}
/*ESC key键的模拟*/
void Esc()
{
    keybd_event(0x1B, , , );
    keybd_event(0x1B, , , );
}
/*SPACE空格 key键的模拟*/
void Space()
{
    keybd_event(0x20, , , );
    keybd_event(0x20, , , );
}
/*PAGE UP key键的模拟*/
void PageUp()
{
    keybd_event(0x21, , , );
    keybd_event(0x21, , , );
}
/*PAGE DOWN key键的模拟*/
void PageDown()
{
    keybd_event(0x22, , , );
    keybd_event(0x22, , , );
}
/*END key键的模拟*/
void End()
{
    keybd_event(0x23, , , );
    keybd_event(0x23, , , );
}
/*Home key键的模拟*/
void Home()
{
    keybd_event(0x24, , , );
    keybd_event(0x24, , , );
}
/*LEFT ARROW key键的模拟*/
void LeftArrow()
{
    keybd_event(0x25, , , );
    keybd_event(0x25, , , );
}
/*RIGHT ARROW key键的模拟*/
void RightArrow()
{
    keybd_event(0x27, , , );
    keybd_event(0x27, , , );
}
/*UP ARROW key键的模拟*/
void UpArrow()
{
    keybd_event(0x26, , , );
    keybd_event(0x26, , , );
}
/*DOWN ARROW key键的模拟*/
void DownArrow()
{
    keybd_event(0x28, , , );
    keybd_event(0x28, , , );
}
/*SELECT key键的模拟*/
void Select()
{
    keybd_event(0x29, , , );
    keybd_event(0x29, , , );
}
/*EXECUTE key键的模拟*/
void Execute()
{
    keybd_event(0x2B, , , );
    keybd_event(0x2B, , , );
}
/*PRINT SCREEN key键的模拟*/
void PrintScreen()
{
    keybd_event(0x2C, , , );
    keybd_event(0x2C, , , );
}
/*INSERT key键的模拟*/
void Insert()
{
    keybd_event(0x2D, , , );
    keybd_event(0x2D, , , );
}
/*DELETE key键的模拟*/
void Delete()
{
    keybd_event(0x2E, , , );
    keybd_event(0x2E, , , );
}
/*HELP key键的模拟*/
void Help()
{
    keybd_event(0x2F, , , );
    keybd_event(0x2F, , , );
}
 
/*Left Windows key键的模拟*/
void LeftWin()
{
    keybd_event(0x5B, , , );
    keybd_event(0x5B, , , );
}
/*Right Windows key键的模拟*/
void RightWin()
{
    keybd_event(0x5C, , , );
    keybd_event(0x5C, , , );
}
/*0 key键的模拟*/
void NumberThero()
{
    keybd_event(0x60, , , );
    keybd_event(0x60, , , );
}
/*1 key键的模拟*/
void NumberOne()
{
    keybd_event(0x61, , , );
    keybd_event(0x61, , , );
}
/*2 key键的模拟*/
void NumberTwo()
{
    keybd_event(0x62, , , );
    keybd_event(0x62, , , );
}
/*3 key键的模拟*/
void NumberThree()
{
    keybd_event(0x63, , , );
    keybd_event(0x63, , , );
}
/*4 key键的模拟*/
void NumberFour()
{
    keybd_event(0x64, , , );
    keybd_event(0x64, , , );
}
/*5 key键的模拟*/
void NumberFive()
{
    keybd_event(0x65, , , );
    keybd_event(0x65, , , );
}
/*6 key键的模拟*/
void NumberSix()
{
    keybd_event(0x66, , , );
    keybd_event(0x66, , , );
}
/*7 key键的模拟*/
void NumberSeven()
{
    keybd_event(0x67, , , );
    keybd_event(0x67, , , );
}
/*8 key键的模拟*/
void NumberEight()
{
    keybd_event(0x68, , , );
    keybd_event(0x68, , , );
}
/*9 key键的模拟*/
void NumbeNine()
{
    keybd_event(0x69, , , );
    keybd_event(0x69, , , );
}
/*乘号 key键的模拟*/
void Multiply()
{
    keybd_event(0x6A, , , );
    keybd_event(0x6A, , , );
}
/*加号 key键的模拟*/
void Add()
{
    keybd_event(0x6B, , , );
    keybd_event(0x6B, , , );
}
/*减号 Subtractkey键的模拟*/
void Subtract()
{
    keybd_event(0x6D, , , );
    keybd_event(0x6D, , , );
}
/*除号 /键的模拟*/
void Divide()
{
    keybd_event(0x6F, , , );
    keybd_event(0x6F, , , );
}
/*Separator 分隔符 \ 键的模拟*/
void Separator()
{
    keybd_event(0x6C, , , );
    keybd_event(0x6C, , , );
}
/*F1键的模拟*/
void F1()
{
    keybd_event(0x70, , , );
    keybd_event(0x70, , , );
}
/*F2键的模拟*/
void F2()
{
    keybd_event(0x71, , , );
    keybd_event(0x71, , , );
}
/*F3键的模拟*/
void F3()
{
    keybd_event(0x72, , , );
    keybd_event(0x72, , , );
}
/*F4键的模拟*/
void F4()
{
    keybd_event(0x73, , , );
    keybd_event(0x73, , , );
}
/*F5键的模拟*/
void F5()
{
    keybd_event(0x74, , , );
    keybd_event(0x74, , , );
}
/*F6键的模拟*/
void F6()
{
    keybd_event(0x75, , , );
    keybd_event(0x75, , , );
}
/*F7键的模拟*/
void F7()
{
    keybd_event(0x76, , , );
    keybd_event(0x76, , , );
}
/*F8键的模拟*/
void F8()
{
    keybd_event(0x77, , , );
    keybd_event(0x77, , , );
}
/*F9键的模拟*/
void F9()
{
    keybd_event(0x78, , , );
    keybd_event(0x78, , , );
}
/*F10键的模拟*/
void F10()
{
    keybd_event(0x79, , , );
    keybd_event(0x79, , , );
}
/*F11键的模拟*/
void F11()
{
    keybd_event(0x7A, , , );
    keybd_event(0x7A, , , );
}
/*F12键的模拟*/
void F12()
{
    keybd_event(0x7B, , , );
    keybd_event(0x7B, , , );
}
/*F13键的模拟*/
void F13()
{
    keybd_event(0x7C, , , );
    keybd_event(0x7C, , , );
}
/*F14键的模拟*/
void F14()
{
    keybd_event(0x7D, , , );
    keybd_event(0x7D, , , );
}
/*F15键的模拟*/
void F15()
{
    keybd_event(0x7E, , , );
    keybd_event(0x7E, , , );
}
/*F16键的模拟*/
void F16()
{
    keybd_event(0x7F, , , );
    keybd_event(0x7F, , , );
}
/*NUM LOCK键的模拟*/
void NumLock()
{
    keybd_event(0x90, , , );
    keybd_event(0x90, , , );
}
/* ";:" 键的模拟*/
void ColonAndSemicolon()
{
    keybd_event(0xBA, , , );
    keybd_event(0xBA, , , );
}
/* "+ =" 键的模拟*/
void PlusEquals()
{
    keybd_event(0xBB, , , );
    keybd_event(0xBB, , , );
}
/* "," 键的模拟*/
void Comma()
{
    keybd_event(0xBC, , , );
    keybd_event(0xBC, , , );
}
/* "- _" 键的模拟*/
void MinusHyphen()
{
    keybd_event(0xBD, , , );
    keybd_event(0xBD, , , );
}
/* "." 键的模拟*/
void Point()
{
    keybd_event(0xBE, , , );
    keybd_event(0xBE, , , );
}
/* "/ ?" 键的模拟*/
void Question()
{
    keybd_event(0xBF, , , );
    keybd_event(0xBF, , , );
}
/* "` ~" 键的模拟*/
void BoLangHao()
{
    keybd_event(0xC0, , , );
    keybd_event(0xC0, , , );
}
/* "[ {" 键的模拟*/
void LeftBrackets()
{
    keybd_event(0xDB, , , );
    keybd_event(0xDB, , , );
}
/* "\ |" 键的模拟*/
void VerticalLine()
{
    keybd_event(0xDC, , , );
    keybd_event(0xDC, , , );
}
/* "] }" 键的模拟*/
void RightBrackets()
{
    keybd_event(0xDD, , , );
    keybd_event(0xDD, , , );
}
/* "' "" 键的模拟*/
void YinHao()
{
    keybd_event(0xDE, , , );
    keybd_event(0xDE, , , );
}
/*win键的模拟*/
void win()
{
    keybd_event(0x5b, , , );//键盘模拟win键按下
    keybd_event(0x5b, , , );//键盘模拟win键松开
}
/*win+d键的组合模拟*/
void winAndD()
{
    keybd_event(0x5b, , , );//键盘模拟键盘按下
    keybd_event('D', , , );//D键按下
    keybd_event('D', , , );//D键松开
    keybd_event(0x5b, , , );//键盘模拟键盘松开
}
/*win+E键的组合模拟*/
void winAndE()
{
    keybd_event(0x5b, , , );//键盘模拟键盘按下
    keybd_event('E', , , );//D键按下
    keybd_event('E', , , );//D键松开
    keybd_event(0x5b, , , );//键盘模拟键盘松开
}
/*win+M键的组合模拟*/
void winAndM()
{
    keybd_event(0x5b, , , );//键盘模拟键盘按下
    keybd_event('M', , , );//D键按下
    keybd_event('M', , , );//D键松开
    keybd_event(0x5b, , , );//键盘模拟键盘松开
}
/*CTRL+ALT+DEL键的组合模拟*/
void ctrlAndAltAndDel()
{
    keybd_event(0x11, , , );    //    CTRL键按下
    keybd_event(0x12, , , );
    keybd_event(0x2E, , , );
    keybd_event(0x2E, , , );
    keybd_event(0x12, , , );
    keybd_event(0x11, , , );//ctrl键松开
}
/*****************************************26个英文字母键模拟*****************************************/
/*A键模拟*/
void AKey()
{
    keybd_event('A', , , );//A键按下
    keybd_event('A', , , );//A键松开
}
/*B键模拟*/
void BKey()
{
    keybd_event('B', , , );
    keybd_event('B', , , );
}
/*C键模拟*/
void CKey()
{
 
    keybd_event('C', , , );
    keybd_event('C', , , );
}
/*D键模拟*/
void DKey()
{
    keybd_event('D', , , );
    keybd_event('D', , , );
}
/*E键模拟*/
void EKey()
{
    keybd_event('E', , , );
    keybd_event('E', , , );
}
/*F键模拟*/
void FKey()
{
    keybd_event('F', , , );
    keybd_event('F', , , );
}
/*G键模拟*/
void GKey()
{
    keybd_event('G', , , );
    keybd_event('G', , , );
 
}
/*H键模拟*/
void HKey()
{
    keybd_event('H', , , );
    keybd_event('H', , , );
}
/*I键模拟*/
void IKey()
{
    keybd_event('I', , , );
    keybd_event('I', , , );
}
/*J键模拟*/
void JKey()
{
    keybd_event('J', , , );
    keybd_event('J', , , );
}
/*K键模拟*/
void KKey()
{
    keybd_event('K', , , );
    keybd_event('K', , , );
}
/*L键模拟*/
void LKey()
{
    keybd_event('L', , , );
    keybd_event('L', , , );
}
/*M键模拟*/
void MKey()
{
    keybd_event('M', , , );
    keybd_event('M', , , );
}
/*N键模拟*/
void NKey()
{
    keybd_event('N', , , );
    keybd_event('N', , , );
}
/*O键模拟*/
void OKey()
{
    keybd_event('O', , , );
    keybd_event('O', , , );
}
/*P键模拟*/
void PKey()
{
    keybd_event('P', , , );
    keybd_event('P', , , );
}
/*Q键模拟*/
void QKey()
{
    keybd_event('Q', , , );
    keybd_event('Q', , , );
}
/*R键模拟*/
void RKey()
{
    keybd_event('R', , , );
    keybd_event('R', , , );
}
/*S键模拟*/
void SKey()
{
    keybd_event('S', , , );
    keybd_event('S', , , );
}
/*T键模拟*/
void TKey()
{
    keybd_event('T', , , );
    keybd_event('T', , , );
}
/*U键模拟*/
void UKey()
{
    keybd_event('U', , , );
    keybd_event('U', , , );
}
/*V键模拟*/
void VKey()
{
    keybd_event('V', , , );
    keybd_event('V', , , );
}
/*W键模拟*/
void WKey()
{
    keybd_event('W', , , );
    keybd_event('W', , , );
}
/*X键模拟*/
void XKey()
{
    keybd_event('X', , , );
    keybd_event('X', , , );
}
/*Y键模拟*/
void YKey()
{
    keybd_event('Y', , , );
    keybd_event('Y', , , );
}
/*Z键模拟*/
void ZKey()
{
    keybd_event('Z', , , );
    keybd_event('Z', , , );
}
 
/*********************************************字符串算法*********************************************/
/*自己实现的字符串检索函数,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 = -;
    for (int i = ; i <= length1 - length2; i++)
    {
        int j = ;
        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", , , , , );
    printf("%c%c%c%c%c\n", , , , , );
    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 = ;
        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 = ; j < lennew; j++)
            {
                p[j] = newstr[j];
            }
            int i = ;
            for (; p[i + lensub] != '\0'; i++)
            {
                p[i + lennew] = p[i + lensub];
                //printf("%c\n", p[i + lensub]);
            }
            p[i] = '\0';
        }
        else
        {
            int j = ;
 
            char temp[];
            while (p[j + lensub] != '\0')
            {
                temp[j + lensub] = p[j + lensub];
                j++;
            }
            temp[j] = '\0';
 
            for (j = ; 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 = ;
        char temp[];
        while (p[j] != '\0')
        {
            temp[j] = p[j];//将substr开始以后的所有字符保存起来
            j++;
        }
        temp[j] = '\0';
 
        for (j = ; j < lennew; j++)//将新字符串一个一个写入p
        {
            p[j] = newstr[j];
        }
        int i = ;
        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 == )
    {
        printf("Move plante %d %c -> %c\n", n, A, C);
    }
    else
    {
        Hanoi(n - , A, C, B);
        printf("Move plante %d %c -> %c\n", n, A, C);
        Hanoi(n- , 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 == )
    {
        return ;
 
    }
    else if (n==)
    {
        return ;
    }
    else
    {
        return Fib(n - ) + Fib(n - );
    }
}
 
/*帕斯卡三角形，m为多项式的(a+b)^m中的m,n为系数所处的位置，返回值为系数值，要满足 m+1 >= n*/
int Paska(int m, int n)
{
    if (n < )
    {
        return ;
    }
    else if (n ==  )
    {
        return ;
    }
    else if ( < n < m )
    {
        return Paska(m - , n) + Paska(m - , n - );
    }
    else if (n == m)
    {
        return ;
    }
    else
    {
        return ;
    }
}
 
/*老鼠走迷宫问题：
使用二维阵列表示迷宫
用2表示墙壁，用0表示空白可以行走，用1表示老鼠可以走出的路径
在起始位置有四个方向可以走，上下左右，起始位置肯定空白
*/
#define M  10    //数组列数
int flag = ;    //是否找到标记
/*查看i行j列处是否为空白，返回1表示成功找到，返回0表示没有找到,找到的路线用1填充*/
int visitArray(int startY, int startX, int endY, int endX, int (*P)[M])
{
        P[startY][startX] = ;
        if (startY == endY && startX == endX)//如果到出口则找到
        {
            flag = ;
        }
        if (flag !=  && P[startY - ][startX] == )//没到到，上路为空白则向上找
            visitArray(startY-,startX,endY,endX,P);
        if (flag !=  && P[startY][startX-] == )//没到到，左路为空白则向左找
            visitArray(startY , startX-, endY, endX, P);
        if (flag !=  && P[startY +][startX] == )//没到到，下路为空白则向下找
            visitArray(startY +, startX, endY, endX, P);
        if (flag !=  && P[startY][startX+] == )//没到到，右路为空白则向右找
            visitArray(startY , startX+, 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 == )
    {
        return ;
    }
    else if (n == )
    {
        return ;
    }
    else
    {
        return stepF(n - ) + stepF(n - );
    }
}
 
/*********************************************数据结构算法*********************************************/
 
/*********************************************文件操作算法*********************************************/
/*从键盘读取字符输出到磁盘文件中，若读取到#，则结束*/
void readFromKey()
{
    char str[];
    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[];
    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 -;
    }
    if (DES == NULL)
    {
        fclose(SRC);
        return -;
    }
    int c = EOF;
    while ((c = fgetc(SRC)) != EOF)
    {
        fputc(c, DES);
    }
    fclose(SRC);
    fclose(DES);
    return ;
 
}
/*将一个长度为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 = ;
        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 = ;
        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 = ;
        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 = ;
        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 = ;
        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 = ;
        res = fread(addr,SIZE, L, F);//第一个参数表示读取内存块的首地址，第二个参数表示每个元素大小，
        //第三个参数表示写入元素数量，第四个参数表示要写入的文件,写入成功会返回写入数量
 
        if (res == L)
        {
            printf("读取成功");
        }
        else
        {
            printf("读取失败");
        }
        fclose(F);
    }
}
/*在黑窗口查看一个文本文件内容，使用cmd命令，path为文件路径*/
void lookFileUseType(char *path)
{
    char cmd[];
    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  -;
    }
    else
    {
        fseek(F, , 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, , , 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 = ;
        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 = ;
        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, , , 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, , 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, , , R);
                fwrite(&s, , , F);
            }
            fclose(F);
            fclose(R);
 
            if (flag)
            {
                remove(rear);
            }
 
        }
    }
}
/*根据指定路径创建一个目录*/
void makeDir(char *path)
{
    char md[];
    sprintf(md, "mkdir %s", path);
    system(md);
}
/*统计英文文档大写字母个数，小写字母个数，数字字符数，统计换行符个数，空格字符个数，逗号字符数，其他字符数，按顺序存放在一个长度为7count数组中，path为文件路径 ,L必须为7*/
void statEnglishFile(char *path, int count[], int L)
{
    if (L != )
        return;
    for (size_t i = ; i < ; i++)
    {
        count[i] = ;
    }
 
    FILE *F = fopen(path, "r");
    if (F == NULL)
    {
        printf("打开文件失败");
    }
    else
    {
        char ch;
        while ((ch = fgetc(F)) != EOF)
        {
            if (ch > 'A' && ch < 'Z')
            {
                count[]++;
            }
            else if (ch > 'a' && ch < 'z')
            {
                count[]++;
            }
            else if (ch > '' && ch < '')
            {
                count[]++;
            }
            else if (ch == '\n')
            {
                count[]++;
            }
            else if (ch == ' ')
            {
                count[]++;
            }
            else if (ch == ',')
            {
                count[]++;
            }
            else
            {
                count[]++;
            }
        }
 
        fclose(F);
    }
 
}
/*统计双字节字符*/
int statFileDoubleChar(char *path)
{
    FILE *F = fopen(path, "r");
    int numc = ;//双字节字符
    if (F == NULL)
    {
        printf("文件打开失败");
        perror("失败原因：");
    }
    else
    {
        int ch;//必须用int，汉字占两个字节，char装不下，int占四个字节
 
        int nume = ;//英文字符
        int numn = ;//数字字数
 
        while ((ch = fgetc(F)) != EOF)
        {
            if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'))
            {
                nume++;
            }
            else if (ch >= '' && ch <= '')
            {
                numn++;
            }
            else if (ch > )//判定ch为双字节字符
            {
                ch = fgetc(F);//在读取一个
                numc++;
            }
            else
            {
 
            }
        }
        fclose(F);
 
    }
    return numc;
}
/*统计汉字字符，汉字采用GBK编码*/
int statFileChineseChar(char *path)
{
    FILE *F = fopen(path, "r");
    int numc = ;//汉字字符
    if (F == NULL)
    {
        printf("文件打开失败");
        perror("失败原因：");
    }
    else
    {
        int ch;//必须用int，汉字占两个字节，char装不下，int占四个字节
 
        int nume = ;//英文字符
        int numn = ;//数字字数
 
        while ((ch = fgetc(F)) != EOF)
        {
            if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'))
            {
                nume++;
            }
            else if (ch >= '' && ch <= '')
            {
                numn++;
            }
            else if (ch > )//判定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[];
    sprintf(cmd, "for /r \"%s\" %%i in (%s.%s) do @echo %%i >> \"%s\"", searchpath, frontname, rearname, outputfile);
    system(cmd);
    char show[];
    sprintf(show, "type %s", outputfile);
    system(show);
 
}
/*linux下在路径searchpath下搜索文件名前缀为frontname后缀为rearname的文件，如果两者有一个为*代表通配符，统配任何哪种格式的文件，outputfile为存储找到的文件路径信息的文件*/
void searchFileInLinux(char *searchpath, char *frontname, char *rearname, char *outputfile)
{
    char cmd[];
    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 = ; i < L;)
        {
            if ((ch = fgetc(F)) != EOF)
            {
 
                ch = ch + key[i];
                fputc(ch, P);
                i++;
                if (i == L)
                    i = ;
            }
            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 = ; i < L;)
        {
            if ((ch = fgetc(F)) != EOF)
            {
 
                ch = ch - key[i];
                fputc(ch, P);
                i++;
                if (i == L)
                    i = ;
            }
            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  -;
    }
    else
    {
        fseek(F, , SEEK_END);//将文件指针移动到文件末尾
        int length = ftell(F);//计算文件指针到文件开头的字节数，即就是文件大小
        int yushu = length % count;//余数
        int size = length / count; //前面count-1份每一分大小为size，最后一份为size + yushu
        for (int i = ; i <= count; i++)
        {
            char savefile[];
            sprintf(savefile, "%s%d%s", savepath, i, savename);
            printf("%s", savefile);
            FILE *P = fopen(savefile, "wb");
            if (P == NULL)
            {
                fclose(F);
                return -;
            }
            else
            {
                fseek(F, (i - )*size, SEEK_SET);
                if (i == count)
                {
                    for (int j = ; j <= size + yushu; j++)
                    {
                        int c = fgetc(F);
                        fputc(c, P);
                    }
                }
                else
                {
                    for (int j = ; j < size; j++)
                    {
                        int c = fgetc(F);
                        fputc(c, P);
                    }
                }
 
            }
            fclose(P);
        }
        fclose(F);
        return ;
    }
 
}
/*合并文件，将文件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 -;
    }
    else
    {
 
        for (int i = ; i < count; i++)
        {
            char str[];
            fgets(str, , F);//每次读取一行字符串，读到末尾为0
            printf("%s", str);
            int len = strlen(str);
            str[len - ] = '\0';
            printf("%s", str);
            FILE *P = fopen(str, "rb");
            if (P == NULL)
            {
                printf("打开文件失败");
                fclose(F);
                fclose(BF);
                return -;
            }
            else
            {
                int c = fgetc(P);
                while (c != EOF)
                {
 
                    fputc(c, BF);
                    c = fgetc(P);
                }
            }
            fclose(P);
 
        }
 
    }
    fclose(F);
    fclose(BF);
    return ;
}
 
/*写入一行文本到文件将一行字符串str写入文件path中，使用系统命令,mode表示模式，非0表示追加模式，0表示重新从头写入*/
void writeStringToFile(char *str, char *path, int mode)
{
    char cmd[];
    if (mode == )
    {
        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 == )
    {
        F = fopen(path, "wb");
    }
    else
    {
        F = fopen(path, "ab");
    }
    if (F == NULL)
    {
        printf("文件打开失败");
        return ;
    }
    else
    {
        int len = strlen(str);
        for (int i = ; 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[];
        while (fgets(str, , 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 ;
    }
    else
    {
        char str[];
        int num = ;//记录行号，从第0行开始
        while (fgets(str, , 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 ;
}
 
/*文本文件删除，在文件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 ;
    }
    else
    {
        char str[];
        while (fgets(str, , 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 ;
}
 
/*文本文件修改，在文件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 ;
    }
    else
    {
        char str[];
        while (fgets(str, , 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 ;
}
 
/*文本文件增加，在文件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 ;
    }
    else
    {
        char str[];
        while (fgets(str, , 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 ;
}
 
/*在文件path中搜索字符串str所在行然后打印出来*/
void printStringInLine(char *substr, char *path)
{
    FILE *F = fopen(path, "r");
    if (F == NULL)
    {
        printf("打开文件失败");
        return;
    }
    else
    {
        char str[];
        while (fgets(str, , 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[];
        int num = ;
        while (fgets(str, , F))//读取一行没有到达文件末尾就一直读
        {
 
            num++;
            if (num == n)//找到
            {
                puts(str);
            }
 
        }
    }
    fclose(F);
}

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

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

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