主頁 >  其他 > 中綴，后綴，前綴運算式的計算以及轉化詳解

中綴，后綴，前綴運算式的計算以及轉化詳解

2020-10-09 03:36:03 其他

資料結構正好學到堆疊，中綴，前綴，后綴運算式把人繞的不行，寫一個博客也算是總結一下這5個演算法：中綴運算式的計算，中綴運算式轉后綴運算式，后綴運算式計算，中綴運算式轉前綴運算式，前綴運算式計算

中綴運算式的計算

思路：
首先設立兩個堆疊，一個operator（運算子）堆疊，一個operand（運算元）堆疊，輸入數字進入operand堆疊，輸入運算子進入operator堆疊，運算式以’#‘開始和結束，
對于字符進堆疊，需要比較當前輸入的字符和operator堆疊頂字符的優先級大小：若當前運算子優先級高于堆疊頂運算子，則當前運算子進堆疊；若當前運算子優先級低于堆疊頂運算子，則堆疊頂運算子出堆疊，并且operand堆疊頂的兩個運算子也出堆疊，三者進行運算后的結果再次存入operand運算元堆疊，此時的當前運算子再繼續和堆疊頂運算子比較，直到優先級大于堆疊頂運算子為止，
當兩個’#'相遇時，也就是運算式結束是，讀取operand堆疊的堆疊頂元素的值，即為中綴運算式的值，

代碼共設12個函式：
（1）兩個堆疊的基本操作6個函式：Init(),Push(),Pop()
（2）判斷字符是否為數字的函式 In(char ch)
（3）獲取數字堆疊堆疊頂元素的函式GetTop1(Operand S)
（4）獲取運算子堆疊堆疊頂元素的函式GetTop2(Operator S)
（5）比較堆疊頂運算子和當前運算子優先級的函式Compare(Operator S,char ch)
（6）計算pop出的運算子和兩個運算元的函式Execute(int a,int b,char op)
（7）計算中綴運算式的值的函式 ExpEvaluation()

在這里我使用了一個二維陣列來存盤運算子的優先級，需要注意的是要搞清行和列哪一個是當前運算子，哪一個是堆疊頂運算子

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#define MAXSIZE 100
char A[7] = {'+','-','*','/','(',')','#'};
char B[7][7] = {
    {'>','>','<','<','<','>','>'},
    {'>','>','<','<','<','>','>'},
    {'>','>','>','>','<','>','>'},
    {'>','>','>','>','<','>','>'},
    {'<','<','<','<','<','=','!'},
    {'>','>','>','>','!','>','>'},
    {'<','<','<','<','<','!','='}
};

typedef struct
{
    int* elem;
    int top;
}Operand;//運算元堆疊
typedef struct
{
    char* elem;
    int top;
}Operator;//運算子堆疊
void Init_Operand(Operand* S)//初始化數字堆疊
{
    S->elem = (int*)malloc(sizeof(int)*MAXSIZE);
    S->top = -1;
    if(S->elem == NULL)
    {
        printf("記憶體分配失敗!\n");
        exit(-1);
    }
    else
        printf("記憶體分配成功!\n");
}
void Push_Operand(Operand* S,int x)//數字x進堆疊
{
    if(S->top == MAXSIZE-1)
    {
        printf("堆疊滿!\n");
        exit(-1);
    }
    else
    {
        S->top++;
        S->elem[S->top] = x;
        printf("%d\n",S->elem[S->top]);
        printf("入堆疊成功!\n");
    }
}
void Pop_Operand(Operand* S,int *x)//數字出堆疊，將值存盤在x中
{
    if(S->top<0)
    {
        printf("堆疊空!\n");
        exit(-1);
    }
    else
    {
        *x = S->elem[S->top];
        S->top--;
        printf("%d\n",*x);
        printf("出堆疊成功!\n");
    }
}
void Init_Operator(Operator* S)//初始化運算子堆疊
{
    S->elem = (char*)malloc(sizeof(char)*MAXSIZE);
    S->top = -1;
    if(S->elem == NULL)
    {
        printf("記憶體分配失敗!\n");
        exit(-1);
    }
    else
        printf("記憶體分配成功!\n");
}
void Push_Operator(Operator* S,char ch)//運算子ch進堆疊
{
    if(S->top == MAXSIZE-1)
    {
        printf("堆疊滿!\n");
        exit(-1);
    }
    else
    {
        S->top++;
        S->elem[S->top] = ch;
        printf("%c",S->elem[S->top]);
        printf("進堆疊成功!\n");
    }
}
void Pop_Operator(Operator* S,char* ch)//運算子ch出堆疊，將值儲存在ch中
{
    if(S->top<0)
    {
        printf("堆疊空!\n");
        exit(-1);
    }
    else
    {
        *ch = S->elem[S->top];
        S->top--;
        printf("%c",*ch);
        printf("出堆疊成功!\n");
    }
}
bool In(char ch)//判斷字符ch是否為數字，不是的話回傳true，是的話回傳false
{
    for(int i=0;i<7;i++)
    {
        if(ch == A[i])
            return true;
    }
    return false;
}
int GetTop1(Operand S)//獲取數字堆疊堆疊頂運算子的值
{
    int x;
    x = S.elem[S.top];
    return x;
}
char GetTop2(Operator S)//獲取字符堆疊堆疊頂運算子的值
{
    char ch;
    ch = S.elem[S.top];
    return ch;
}
char Compare(Operator S,char ch)//比較堆疊頂運算子和當前運算子的優先級
{
    int temp1,temp2;
    char c = GetTop2(S);//獲取堆疊頂運算子
    for(int i=0;i<7;i++)
    {
        if(c==A[i])
            temp1 = i;//獲取二維陣列的行坐標
        if(ch==A[i])
            temp2 = i;//獲取二維陣列的列坐標
    }
    return B[temp1][temp2];
}
int Execute(int a,int b,char op)//b是先彈出的，a是后彈出的
{
    int v;
    switch(op)
    {
        case '+':v = a+b;break;
        case '-':v = a-b;break;
        case '*':v = a*b;break;
        case '/':v = a/b;break;
    }
    return v;
}
void ExpEvaluation()
{
    int value;
    char ch,op,x;
    int a,b;
    Operand s1;
    Operator s2;
    Init_Operand(&s1);//初始化數字堆疊
    Init_Operator(&s2);//初始化字符堆疊
    Push_Operator(&s2,'#');
    ch = getchar();
    while(ch!='#'||GetTop2(s2)!='#')
    {
        if(!In(ch))//不是執行運算子if
        {
            ch = ch - '0';
            Push_Operand(&s1,ch);
            fflush(stdin);//清慷訓沖區
            ch = getchar();
        }
        else
        {
            switch(Compare(s2,ch))
            {
                case '<':
                //堆疊頂運算子優先級低于當前運算子,入堆疊
                    {
                        Push_Operator(&s2,ch);
                        fflush(stdin);
                        ch = getchar();
                    }break;
                case '>':
                //堆疊頂運算子優先級高于當前運算子,出堆疊
                    {
                        Pop_Operator(&s2,&op);
                        Pop_Operand(&s1,&b);
                        Pop_Operand(&s1,&a);
                        value = Execute(a,b,op);
                        Push_Operand(&s1,value);
                    }break;
                case '=':
                    {
                        Pop_Operator(&s2,&x);
                        fflush(stdin);
                        ch = getchar();
                    }break;
            }
        }
    }
    value = GetTop1(s1);
    printf("中綴運算式的值為:%d",value);
}
int main()
{
    ExpEvaluation();
    return 0;
}

中綴運算式轉后綴運算式并計算

思路：
設立一個運算子堆疊operator和一個字符陣列，字符陣列用來存盤需要輸出的字符（包括數字和運算子），operator堆疊用來比較當前運算子和堆疊頂運算子的優先級大小，同樣運算式以‘#’開頭和結尾，
輸入若為數字直接存入字符陣列，若為運算子則壓入operator堆疊中，在入堆疊時，若當前運算子的優先級高于operator堆疊頂運算子，則當前運算子入堆疊；若當前運算子優先級低于operator堆疊頂運算子，則堆疊頂運算子出堆疊，進入字符陣列中，當前運算子再繼續與此時的堆疊頂運算子進行比較，直到當前運算子的優先級大于堆疊頂運算子為止，
對于括號，左括號‘(’直接入堆疊，當遇到右括號’)'時，不管優先級，開始將堆疊頂運算子按上面規律彈出，直到遇到左括號，將左括號彈出，然后讀取下一個字符，
后綴運算式的計算很簡單，只需要建立一個operand堆疊，當遇到數字則入堆疊，遇到字符，則彈出堆疊頂的兩個元素進行計算后將結果入堆疊，依次回圈，
代碼如下：

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#define MAXSIZE 100
char A[7] = {'+','-','*','/','(',')','#'};
char B[7][7] = {
    {'>','>','<','<','<','>','>'},
    {'>','>','<','<','<','>','>'},
    {'>','>','>','>','<','>','>'},
    {'>','>','>','>','<','>','>'},
    {'<','<','<','<','<','=','!'},
    {'>','>','>','>','!','>','>'},
    {'<','<','<','<','<','!','='}
};

typedef struct
{
    char* elem;
    int top;
}Operator;//存盤運算子的堆疊operator
typedef struct
{
    char *elem;
    int top;
}Array;//定義一個陣列的結構體型別，用來存盤字符
typedef struct
{
    int* elem;
    int top;
}Operand;//用來計算后綴運算式的值的數字堆疊
void Init_Operator(Operator* S)
{
    S->elem = (char*)malloc(sizeof(char)*MAXSIZE);
    S->top = -1;
    if(S->elem == NULL)
    {
        printf("記憶體分配失敗!\n");
        exit(-1);
    }
    else
        printf("記憶體分配成功!\n");
}
void Push(Operator* S,char ch)
{
    if(S->top == MAXSIZE-1)
    {
        printf("堆疊滿!\n");
        exit(-1);
    }
    else
    {
        S->top++;
        S->elem[S->top] = ch;
        printf("%c\n",S->elem[S->top]);
        printf("入堆疊成功!\n");
    }
}
void Pop(Operator* S,char* ch)
{
    if(S->top<0)
    {
        printf("堆疊空!\n");
        exit(-1);
    }
    else
    {
        *ch = S->elem[S->top];
        S->top--;
        printf("%c\n",*ch);
        printf("出堆疊成功!\n");
    }
}
void Init_Array(Array* A)//初始化字符陣列
{
    A->elem = (char*)malloc(sizeof(char)*MAXSIZE);
    A->top = -1;
    if(A->elem == NULL)
    {
        printf("記憶體分配失敗!\n");
        exit(-1);
    }
    else
        printf("記憶體分配成功!\n");
}
void Add(Array* A,char ch)//因為只需要向字符陣列中加入元素，故之定義add()
{
    if(A->top==MAXSIZE)
    {
        printf("堆疊滿!\n");
        exit(-1);
    }
    else
    {
        A->top++;
        A->elem[A->top] = ch;
        printf("%c ",A->elem[A->top]);
        printf("入堆疊成功!\n");
    }
}
void Init_Operand(Operand* S)//初始化數字堆疊
{
    S->elem = (int*)malloc(sizeof(int)*MAXSIZE);
    S->top = -1;
    if(S->elem == NULL)
    {
        printf("記憶體分配失敗!\n");
        exit(-1);
    }
    else
        printf("記憶體分配成功!\n");
}
void Push_Operand(Operand* S,int x)
{
    if(S->top==MAXSIZE-1)
    {
        printf("堆疊滿!\n");
        exit(-1);
    }
    else
    {
        S->top++;
        S->elem[S->top] = x;
        printf("%d ",S->elem[S->top]);
        printf("記憶體分配成功!\n");
    }
}
void Pop_Operand(Operand* S,int *x)
{
    if(S->top<0)
    {
        printf("堆疊空!\n");
        exit(-1);
    }
    else
    {
        *x = S->elem[S->top];
        S->top--;
        printf("%d\n",*x);
        printf("出堆疊成功!\n");
    }
}
bool In(char ch)//是字符回傳true,是數字回傳false
{
    for(int i=0;i<7;i++)
    {
        if(ch==A[i])
            return true;
    }
    return false;
}
char GetTop(Operator S)
{
    char ch;
    ch = S.elem[S.top];
    return ch;
}
int Execute(int a,int b,char op)
{
    int v;
    switch(op)
    {
        case '+':v = a+b;break;
        case '-':v = a-b;break;
        case '*':v = a*b;break;
        case '/':v = a/b;break;
    }
    return v;
}
char Compare(char ch,Operator S)
{
    int temp1,temp2;
    char c;
    c = GetTop(S);
    for(int i=0;i<7;i++)
    {
        if(c==A[i])
            temp1 = i;
        if(ch==A[i])
            temp2 = i;
    }
    return B[temp1][temp2];
}
void print(char ch)
{
    if(In(ch))//是字符執行if陳述句
        printf("%c ",ch);
    else
        printf("%d ",ch);
}
void print_Array(Array A)
{
    for(int i=0;i<=A.top;i++)
    {
        printf("%c",A.elem[i]);
    }
}
void Calcul_Exp(Array A)//后綴運算式的計算
{
    int a,b,value;
    //char temp;
    Operand Stack;
    Init_Operand(&Stack);
    for(int i=0;i<=A.top;i++)
    {
        if(!In(A.elem[i]))//是數字，入堆疊
        {
            A.elem[i] = A.elem[i] - '0';
            Push_Operand(&Stack,A.elem[i]);
        }
        else//字符,故 pop it
        {
            Pop_Operand(&Stack,&b);
            Pop_Operand(&Stack,&a);
            value = Execute(a,b,A.elem[i]);
            Push_Operand(&Stack,value);
        }
    }
    Pop_Operand(&Stack,&value);
    printf("后綴運算式的值為:%d",value);
}
void Transfer()
{
    char ch,op;
    Operator Stack;
    Array A;
    Init_Array(&A);
    Init_Operator(&Stack);
    Push(&Stack,'#');
    ch = getchar();
    while(ch!='#')
    {
        if(!In(ch))//不是字符
        {
            Add(&A,ch);
            fflush(stdin);
            ch = getchar();
        }
        else//是字符
        {
            switch(Compare(ch,Stack))
            {
            case '<'://堆疊頂運算子優先級低于當前運算子
                {
                    Push(&Stack,ch);
                    fflush(stdin);
                    ch = getchar();
                }break;
            case '>'://堆疊頂運算子的優先級高于當前運算子
                {
                    if(GetTop(Stack)==')')
                        Pop(&Stack,&op);
                    else
                    {
                        Pop(&Stack,&op);
                        Add(&A,op);
                    }
                }break;
            case '=':
                {
                    Pop(&Stack,&op);
                    fflush(stdin);
                    ch = getchar();
                }break;
            }
        }
    }
    //printf("OK？\n");
    while(GetTop(Stack)!='#')
    {
        Pop(&Stack,&op);
        Add(&A,op);
    }
    print_Array(A);
    Calcul_Exp(A);
}
int main()
{
    Transfer();
    //Calcul_Exp();
    return 0;
}

中綴運算式轉前綴運算式

思路：
首先應建立兩個陣列結構體，一個用來存盤輸入的中綴運算式，一個用來存盤轉化后的前綴運算式；再應建立一個運算子operator堆疊，用來判定運算子的優先級大小，
首先輸入中綴運算式，將中綴運算式存放在一個字符陣列中，再從右至左讀取中綴運算式中的字符，若為數字則直接存放入前綴運算式陣列中；若為字符，則需判定該字符與operator堆疊堆疊頂字符的優先級：若該字符優先級高于堆疊頂運算子，則該字符入堆疊，若低于，則堆疊頂運算子出堆疊，該字符再與此時的堆疊頂運算子比較，直到其優先級高于堆疊頂運算子為止，
對于右括號‘)’，應壓入堆疊中；對于左括號‘(’，應依次將堆疊頂運算子彈出直到遇到右括號為止‘)’，值得注意的是，左括號和右括號都不需要進入前綴運算式陣列中，
注：為了簡便運算，我將運算子優先級表稍作調整

代碼如下：

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#define MAXSIZE 100
char A[7] = {'+','-','*','/','(',')','#'};
char B[7][7] = {//此處對表做了一些修改
    {'>','>','<','<','>','<','>'},
    {'>','>','<','<','>','<','>'},
    {'>','>','>','>','>','<','>'},
    {'>','>','>','>','>','<','>'},
    {'<','<','<','<','>','=','!'},
    {'<','<','<','<','=','<','>'},
    {'<','<','<','<','<','<','='}
};

typedef struct
{
    char* elem;
    int top;
}Operator;
typedef struct
{
    char* elem;
    int top;
}Array;
void Init_Operator(Operator* S)
{
    S->elem = (char*)malloc(sizeof(char)*MAXSIZE);
    S->top = -1;
    if(S->elem == NULL)
    {
        printf("記憶體分配失敗!\n");
        exit(-1);
    }
    else
        printf("記憶體分配成功!\n");
}
void Push(Operator* S,char ch)
{
    if(S->top == MAXSIZE-1)
    {
        printf("堆疊滿!\n");
        exit(-1);
    }
    else
    {
        S->top++;
        S->elem[S->top] = ch;
        printf("%c\n",S->elem[S->top]);
        printf("入堆疊成功!\n");
    }
}
void Pop(Operator* S,char* ch)
{
    if(S->top<0)
    {
        printf("堆疊空!\n");
        exit(-1);
    }
    else
    {
        *ch = S->elem[S->top];
        S->top--;
        printf("%c\n",*ch);
        printf("出堆疊成功!\n");
    }
}
void Init_Array(Array* A)
{
    A->elem = (char*)malloc(sizeof(char)*MAXSIZE);
    A->top = -1;
    if(A->elem==NULL)
    {
        printf("記憶體分配失敗!\n");
        exit(-1);
    }
    else
        printf("記憶體分配成功!\n");
}
void Add(Array* A,char ch)
{
    printf("這里呢?\n");
    if(A->top==MAXSIZE-1)
    {
        printf("堆疊滿!\n");
        exit(-1);
    }
    else
    {
        A->top++;
        A->elem[A->top] = ch;
        printf("%c\n",A->elem[A->top]);
        printf("插入成功!\n");
    }
}
bool In(char ch)//是運算子回傳true,是數字回傳false
{
    for(int i=0;i<7;i++)
    {
        if(ch==A[i])
            return true;
    }
    return false;
}
char GetTop(Operator S)
{
    char ch;
    ch = S.elem[S.top];
    //printf("%c\n",ch);
    return ch;
}
char Compare(char ch,Operator S)
{
    char c;
    int temp1,temp2;
    c = GetTop(S);
    for(int i=0;i<7;i++)
    {
        if(c==A[i])
            temp1 = i;
        if(ch==A[i])
            temp2 = i;
    }
    //printf("%c\n",B[temp1][temp2]);
    return B[temp1][temp2];
}
void print(Array A)
{
    for(int i=A.top;i>=0;i--)
    {
        printf("%c",A.elem[i]);
    }
}
void Transfer()
{
    char ch,op,temp;
    Array A1,A2;
    int i=0;
    Operator Stack;
    Init_Array(&A1);
    Init_Array(&A2);
    Init_Operator(&Stack);
    Push(&Stack,'#');
    printf("請輸入中綴運算式:\n");
    ch = getchar();
    while(ch!='#')
    {
        Add(&A1,ch);
        fflush(stdin);
        ch = getchar();
        i = A1.top;
    }
    print(A1);
       while(i>=0)
       {
          if(!In(A1.elem[i]))//是數字執行if陳述句
          {
             printf("第二步?\n");
             temp = A1.elem[i];
             Add(&A2,temp);
             i--;
          }
          else
          {
             switch(Compare(A1.elem[i],Stack))
             {
              case '<'://堆疊頂運算子優先級低于當前運算子
                {
                    Push(&Stack,A1.elem[i]);
                    i--;
                }break;
              case '>'://堆疊頂運算子優先級高于當前運算子
                {
                    Pop(&Stack,&op);
                    Add(&A2,op);
                }break;
              case '=':
                {
                    Pop(&Stack,&op);
                    i--;
                }break;
            }
        }
    }
    while(GetTop(Stack)!='#')
    {
        Pop(&Stack,&op);
        Add(&A2,op);
        printf("%c\n",op);
    }
    print(A2);
}
int main()
{
    Transfer();
    return 0;
}

前綴運算式的計算

思路：
首先建立一個operand堆疊，由于將中綴運算式轉換為前綴后是將其存盤在一個字符陣列中的，則從左向右讀取該陣列中的元素，遇到數字進入operand堆疊，遇到運算子，則將堆疊頂的兩個元素依次彈出與該運算子進行計算，結果再入operand堆疊，當前綴運算式陣列掃描完成后，則operand堆疊頂的元素值即為前綴運算式的值，
代碼：

//將這些陳述句插入上面代碼即可運行
typedef struct
{
    int* elem;
    int top;
}Operand;
void Init_Operand(Operand* S)
{
    S->elem = (int*)malloc(sizeof(int)*MAXSIZE);
    S->top = -1;
    if(S->elem == NULL)
    {
        printf("記憶體分配失敗!\n");
        exit(-1);
    }
    else
        printf("記憶體分配成功!\n");
}
void Push_Operand(Operand* S,int x)
{
    if(S->top==MAXSIZE-1)
    {
        printf("堆疊滿!\n");
        exit(-1);
    }
    else
    {
        S->top++;
        S->elem[S->top] = x;
        printf("%d ",S->elem[S->top]);
        printf("記憶體分配成功!\n");
    }
}
void Pop_Operand(Operand* S,int *x)
{
    if(S->top<0)
    {
        printf("堆疊空!\n");
        exit(-1);
    }
    else
    {
        *x = S->elem[S->top];
        S->top--;
        printf("%d\n",*x);
        printf("出堆疊成功!\n");
    }
}
int Execute(int a,int b,char op)
{
    int v;
    switch(op)
    {
        case '+':v = a+b;break;
        case '-':v = a-b;break;
        case '*':v = a*b;break;
        case '/':v = a/b;break;
    }
    return v;
}
void Calcul_Exp(Array A)
{
    int a,b,value;
    Operand S;
    Init_Operand(&S);
    for(int i=0;i<=A.top;i++)
    {
        if(!In(A.elem[i]))//是數字執行if陳述句
        {
            A.elem[i] = A.elem[i] - '0';
            //printf("%d\n",A.elem[i]);
            //exit(-1);
            Push_Operand(&S,A.elem[i]);
        }
        else
        {
            Pop_Operand(&S,&b);
            Pop_Operand(&S,&a);
            value = Execute(a,b,A.elem[i]);
            Push_Operand(&S,value);
        }
    }
    Pop_Operand(&S,&value);
    printf("前綴運算式的值為:%d",value);
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/163916.html

標籤：其他

上一篇：mdk5軟體和stm32包的安裝以及stm32程式“LED閃爍”除錯，用Proteus仿真一個51程式設計和仿真

下一篇：建立自己的STM32專案庫(庫函式,Kile)

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 網閘典型架構簡述

    網閘架構一般分為兩種：三主機的三系統架構網閘和雙主機的2+1架構網閘。 三主機架構分別為內端機、外端機和仲裁機。三機無論從軟體和硬體上均各自獨立。首先從硬體上來看，三機都用各自獨立的主板、記憶體及存盤設備。從軟體上來看，三機有各自獨立的作業系統。這樣能達到完全的三機獨立。對于“2+1”系統，“2”分為 ......

    uj5u.com 2020-09-10 02:00:44 more
  • 如何從xshell上傳檔案到centos linux虛擬機里

    如何從xshell上傳檔案到centos linux虛擬機里及：虛擬機CentOs下執行 yum -y install lrzsz命令，出現錯誤：鏡像無法找到軟體包 前言 一、安裝lrzsz步驟 二、上傳檔案 三、遇到的問題及解決方案 總結 前言 提示：其實很簡單，往虛擬機上安裝一個上傳檔案的工具 ......

    uj5u.com 2020-09-10 02:00:47 more
  • 一、SQLMAP入門

    一、SQLMAP入門 1、判斷是否存在注入 sqlmap.py -u 網址/id=1 id=1不可缺少。當注入點后面的引數大于兩個時。需要加雙引號， sqlmap.py -u "網址/id=1&uid=1" 2、判斷文本中的請求是否存在注入 從文本中加載http請求，SQLMAP可以從一個文本檔案中 ......

    uj5u.com 2020-09-10 02:00:50 more
  • Metasploit 簡單使用教程

    metasploit 簡單使用教程 浩先生， 2020-08-28 16:18:25 分類專欄： kail 網路安全 linux 文章標簽： linux資訊安全 編輯 著作權 metasploit 使用教程 前言 一、Metasploit是什么？ 二、準備作業 三、具體步驟 前言 Msfconsole ......

    uj5u.com 2020-09-10 02:00:53 more
  • 游戲逆向之驅動層與用戶層通訊

    驅動層代碼： #pragma once #include <ntifs.h> #define add_code CTL_CODE(FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ANY_ACCESS) /* 更多游戲逆向視頻www.yxfzedu.com ......

    uj5u.com 2020-09-10 02:00:56 more
  • 北斗電力時鐘（北斗授時服務器）讓網路資料更精準

    北斗電力時鐘（北斗授時服務器）讓網路資料更精準 北斗電力時鐘（北斗授時服務器）讓網路資料更精準 京準電子科技官微——ahjzsz 近幾年，資訊技術的得了快速發展，互聯網在逐漸普及，其在人們生活和生產中都得到了廣泛應用，并且取得了不錯的應用效果。計算機網路資訊在電力系統中的應用，一方面使電力系統的運行 ......

    uj5u.com 2020-09-10 02:01:03 more
  • 【CTF】CTFHub 技能樹 彩蛋 writeup

    ?碎碎念 CTFHub：https://www.ctfhub.com/ 筆者入門CTF時時剛開始刷的是bugku的舊平臺，后來才有了CTFHub。 感覺不論是網頁UI設計，還是題目質量，賽事跟蹤，工具軟體都做得很不錯。 而且因為獨到的金幣制度的確讓人有一種想去刷題賺金幣的感覺。 個人還是非常喜歡這個 ......

    uj5u.com 2020-09-10 02:04:05 more
  • 02windows基礎操作

    我學到了一下幾點 Windows系統目錄結構與滲透的作用 常見Windows的服務詳解 Windows埠詳解 常用的Windows注冊表詳解 hacker DOS命令詳解（net user / type /md /rd/ dir /cd /net use copy、批處理 等） 利用dos命令制作 ......

    uj5u.com 2020-09-10 02:04:18 more
  • 03.Linux基礎操作

    我學到了以下幾點 01Linux系統介紹02系統安裝，密碼啊破解03Linux常用命令04LAMP 01LINUX windows： win03 8 12 16 19 配置不繁瑣 Linux：redhat,centos(紅帽社區版)，Ubuntu server,suse unix:金融機構，證券，銀 ......

    uj5u.com 2020-09-10 02:04:30 more
  • 05HTML

    01HTML介紹 02頭部標簽講解03基礎標簽講解04表單標簽講解 HTML前段語言 js1.了解代碼2.根據代碼 懂得挖掘漏洞 （POST注入/XSS漏洞上傳）3.黑帽seo 白帽seo 客戶網站被黑帽植入劫持代碼如何處理4.熟悉html表單 <html><head><title>TDK標題，描述 ......

    uj5u.com 2020-09-10 02:04:36 more
最新发布
  • 2023年最新微信小程式抓包教程

    01 開門見山 隔一個月發一篇文章，不過分。 首先回顧一下《微信系結手機號資料庫被脫庫事件》，我也是第一時間得知了這個訊息，然后跟蹤了整件事情的經過。下面是這起事件的相關截圖以及近日流出的一萬條資料樣本： 個人認為這件事也沒什么，還不如關注一下之前45億快遞資料查詢渠道疑似在近日復活的訊息。 訊息是 ......

    uj5u.com 2023-04-20 08:48:24 more
  • web3 產品介紹：metamask 錢包 使用最多的瀏覽器插件錢包

    Metamask錢包是一種基于區塊鏈技術的數字貨幣錢包，它允許用戶在安全、便捷的環境下管理自己的加密資產。Metamask錢包是以太坊生態系統中最流行的錢包之一，它具有易于使用、安全性高和功能強大等優點。 本文將詳細介紹Metamask錢包的功能和使用方法。 一、 Metamask錢包的功能 數字資 ......

    uj5u.com 2023-04-20 08:47:46 more
  • vulnhub_Earth

    前言 靶機地址->>>vulnhub_Earth 攻擊機ip：192.168.20.121 靶機ip：192.168.20.122 參考文章 https://www.cnblogs.com/Jing-X/archive/2022/04/03/16097695.html https://www.cnb ......

    uj5u.com 2023-04-20 07:46:20 more
  • 從4k到42k，軟體測驗工程師的漲薪史，給我看哭了

    清明節一過，盲猜大家已經無心上班，在數著日子準備過五一，但一想到銀行卡里的余額……瞬間心情就不美麗了。最近，2023年高校畢業生就業調查顯示，本科畢業月平均起薪為5825元。調查一出，便有很多同學表示自己又被平均了。看著這一資料，不免讓人想到前不久中國青年報的一項調查：近六成大學生認為畢業10年內會 ......

    uj5u.com 2023-04-20 07:44:00 more
  • 最新版本 Stable Diffusion 開源 AI 繪畫工具之中文自動提詞篇

    🎈 標簽生成器 由于輸入正向提示詞 prompt 和反向提示詞 negative prompt 都是使用英文，所以對學習母語的我們非常不友好 使用網址：https://tinygeeker.github.io/p/ai-prompt-generator 這個網址是為了讓大家在使用 AI 繪畫的時候 ......

    uj5u.com 2023-04-20 07:43:36 more
  • 漫談前端自動化測驗演進之路及測驗工具分析

    隨著前端技術的不斷發展和應用程式的日益復雜，前端自動化測驗也在不斷演進。隨著 Web 應用程式變得越來越復雜，自動化測驗的需求也越來越高。如今，自動化測驗已經成為 Web 應用程式開發程序中不可或缺的一部分，它們可以幫助開發人員更快地發現和修復錯誤，提高應用程式的性能和可靠性。 ......

    uj5u.com 2023-04-20 07:43:16 more
  • CANN開發實踐：4個DVPP記憶體問題的典型案例解讀

    摘要：由于DVPP媒體資料處理功能對存放輸入、輸出資料的記憶體有更高的要求（例如，記憶體首地址128位元組對齊），因此需呼叫專用的記憶體申請介面，那么本期就分享幾個關于DVPP記憶體問題的典型案例，并給出原因分析及解決方法。 本文分享自華為云社區《FAQ_DVPP記憶體問題案例》，作者：昇騰CANN。 DVPP ......

    uj5u.com 2023-04-20 07:43:03 more
  • msf學習

    msf學習 以kali自帶的msf為例 一、msf核心模塊與功能 msf模塊都放在/usr/share/metasploit-framework/modules目錄下 1、auxiliary 輔助模塊，輔助滲透（埠掃描、登錄密碼爆破、漏洞驗證等） 2、encoders 編碼器模塊，主要包含各種編碼 ......

    uj5u.com 2023-04-20 07:42:59 more
  • Halcon軟體安裝與界面簡介

    1. 下載Halcon17版本到到本地 2. 雙擊安裝包后 3. 步驟如下 1.2 Halcon軟體安裝 界面分為四大塊 1. Halcon的五個助手 1) 影像采集助手：與相機連接，設定相機引數，采集影像 2) 標定助手：九點標定或是其它的標定，生成標定檔案及內參外參，可以將像素單位轉換為長度單位 ......

    uj5u.com 2023-04-20 07:42:17 more
  • 在MacOS下使用Unity3D開發游戲

    第一次發博客，先發一下我的游戲開發環境吧。 去年2月份買了一臺MacBookPro2021 M1pro(以下簡稱mbp)，這一年來一直在用mbp開發游戲。我大致分享一下我的開發工具以及使用體驗。 1、Unity 官網鏈接： https://unity.cn/releases 我一般使用的Apple ......

    uj5u.com 2023-04-20 07:40:19 more

Copyright © 2010-2020 有解無憂