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 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<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[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語言。

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM