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