主頁 >  其他 > 資料結構初階：堆疊和佇列

資料結構初階：堆疊和佇列

2021-11-07 08:19:57 其他

文章目錄

    • 堆疊和佇列
      • 1 堆疊
        • 1.1 堆疊的定義和結構
          • 堆疊結構體定義
        • 1.2 堆疊的實作
          • 堆疊初始化和銷毀
          • 堆疊的壓入和彈出
          • 獲取堆疊頂元素
          • 其他基本介面
      • 2 佇列
        • 2.1 佇列的定義和結構
          • 佇列結構體定義
        • 2.2 佇列的實作
          • 佇列初始化和銷毀
          • 隊尾入隊和隊頭出隊
          • 獲取隊頭隊尾元素
          • 其他基本介面
      • 3 堆疊和佇列面試題
          • Example 1 判斷有效括號
          • Example 2 佇列實作堆疊
          • Example 3 堆疊實作佇列
          • Example 4 實作回圈佇列
            • 陣列實作
            • 鏈表實作

堆疊和佇列

堆疊和佇列是兩種資料結構，堆疊和佇列這兩種結構也是線性表，特殊在于它們的操作受到一些限制，

1 堆疊

1.1 堆疊的定義和結構

堆疊是一種特殊的線性表，堆疊只允許在其固定的一端進行插入和洗掉元素的操作，進行資料插入洗掉操作的一端被稱為堆疊頂，另一端被稱為堆疊底，堆疊中的資料元素遵循后進先出的原則，

后進先出，先進后出，即LIFO原則（Last In First Out），

壓堆疊：堆疊的插入操作被稱為壓堆疊，也可以叫做進堆疊、入堆疊，

出堆疊：堆疊的插入操作被稱為出堆疊，或稱彈堆疊，

資料的出入都在堆疊頂，類似于子彈上膛和發射的程序，元素像子彈一樣一個個地被壓入彈夾，再一個個地打出去，這個程序便是壓堆疊和出堆疊，彈夾便是堆疊，

堆疊結構體定義

和線性表類似，堆疊結構可以使用陣列堆疊和鏈式堆疊實作，相對來說，陣列堆疊比鏈式堆疊的結構優勢更大一點，

動態陣列進行尾插尾刪的效率高其次快取命中率高，缺點是動態增容有一定的記憶體消耗，鏈式堆疊需使用雙向鏈表，否則進行尾刪的效率低，但以鏈表頭作堆疊頂進行頭插頭刪的效率要更高，

typedef int STDataType;
typedef struct Stack 
{
	STDataType* a;
	int top;
	int capacity;
}ST;

a指向為堆疊開辟的空間，top指向堆疊頂，相當于順序表的size，

1.2 堆疊的實作

//初始化堆疊
void StackInit(ST* ps);
//入堆疊
void StackPush(ST* ps, STDataType data);
//出堆疊
void StackPop(ST* ps);
//獲取堆疊頂元素
STDataType StackTop(ST* ps);
//獲取堆疊元素個數
int StackSize(ST* ps);
//檢測空堆疊
bool StackEmpty(ST* ps);
//銷毀堆疊
void StackDestroy(ST* ps);
堆疊初始化和銷毀
void StackInit(ST* ps) {
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}
void StackDestroy(ST* ps) {
	assert(ps);
	free(ps->a);
    ps->a = NULL;
	ps->capacity = ps->top = 0;
}

top可以初始化為0，也可以為-1，

  • 若為0，則top總是即將插入元素的下標，或者說是堆疊頂的后一塊空間，其值代表堆疊元素個，
  • 若置為-1，則代表當前堆疊頂位置下標，其值加1代表元素個數，
堆疊的壓入和彈出
void StackPush(ST* ps, STDataType data) {
	assert(ps);
	//檢測容量
	if (ps->capacity == ps->top) {
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* ptr = realloc(ps->a, sizeof(STDataType) * newCapacity);
		if (ptr == NULL) {
			perror("StackPush::realloc");
			exit(-1);
		}
		ps->a = ptr;
        ps->capacity = newCapacity;
	}
	ps->a[ps->top] = data;
	ps->top++;
}
void StackPop(ST* ps) {
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

入堆疊一定記得最后把newCapacity再賦值給capacity，還有擴容時的大小應是陣列元素的大小而不是結構體的大小，

洗掉資料前需要保證堆疊的非空狀態，

獲取堆疊頂元素
STDataType StackTop(ST* ps) {
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}
void test() {
    while (!StackEmpty(&stack)) {
    printf("%d ", StackTop(&stack));
    StackPop(&stack);
	}
}

top-1為當前堆疊頂的下標，同樣要保證堆疊非空，

加上該測驗函式，可以實作回圈列印堆疊元素的功能，

其他基本介面
//獲取堆疊元素個數
int StackSize(ST* ps) {
	assert(ps);
	return ps->top;
}
//檢測空堆疊
bool StackEmpty(ST* ps) {
	assert(ps);
	return !ps->top;
}

!top的值正好可以表示堆疊的有無元素的狀態，當然這樣top必須初始化為0，

2 佇列

2.1 佇列的定義和結構

佇列同樣是一種特殊的線性表，和堆疊相反，佇列只允許在其一端進行插入而在另一端進行洗掉元素的操作，進行資料插入操作的一端被稱為隊尾，進行洗掉操作的另一端被稱為隊頭，佇列中的資料元素遵循先進先出的原則，

入佇列即在隊尾插入資料，出佇列則是在隊頭洗掉資料，

先進先出，后進后出，即FIFO原則（First In First Out），

佇列結構體定義
typedef int QDataType;

typedef struct QueueNode 
{
	QDataType data;
	struct QueueNode* next;
} QueueNode;

typedef struct Queue 
{
	struct QueueNode* head;
	struct QueueNode* tail;
} Queue;

佇列需要兩個指標標識隊頭和隊尾，以便管理佇列的元素，而佇列元素即結點用單鏈表的結構實作即可，把結點封裝成一個結構體，佇列再封裝成一個結構體存入指向結點結構體的指標，

隊尾指標是根據佇列這個物件只在隊尾進行插入操作的特點而設計的，原先的單鏈表表尾有插入洗掉兩種操作，故定義尾指標的意義不大，將存盤的功能交給雙向鏈表完成，

結構的定義是很靈活的，不定義Queue結構體或者說不將頭尾指標封裝起來也是可以的，那么函式就需要定義成：

void QueueInit(QueueNode** pphead, QueueNode** pptail);

顯然，封裝成結構體不失為一種良好的代碼風格，

2.2 佇列的實作

//佇列初始化
void QueueInit(Queue* pq);
//佇列銷毀
void QueueDestroy(Queue* pq);
//佇列入隊
void QueuePush(Queue* pq, QDataType x);
//佇列出隊
void QueuePop(Queue* pq);
//獲取隊頭資料
QDataType QueueFront(Queue* pq);
//獲取隊尾資料
QDataType QueueBack(Queue* pq);
//獲取佇列元素個數
int QueueSize(Queue* pq);
//檢測佇列是否為空
bool QueueEmpty(Queue* pq);
佇列初始化和銷毀
void QueueInit(Queue* pq) {
    assert(pq);
    pq->head = NULL;
	pq->tail = NULL;
}
void QueueDestroy(Queue* pq) {
    assert(pq);
	QueueNode* cur = pq->head;
	while (cur) {
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
}

初始化和銷毀并沒有傳二級指標，因為傳遞結構體的地址，而兩個指標是封裝在結構體里的，創建佇列在函式外，所以傳其地址就行，同時加上斷言以防空指標，

隊尾入隊和隊頭出隊
void QueuePush(Queue* pq, QDataType x) {//Enqueue
	assert(pq);
	QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newNode == NULL) {
		perror("Queue::malloc");
		exit(-1);
	}
	newNode->data = x;
	newNode->next = NULL;
	//佇列為空
	if (pq->head == NULL) {
		pq->head = pq->tail = newNode;
	}
	else {
		pq->tail->next = newNode;
		pq->tail = newNode;
	}
}
void QueuePop(Queue* pq) {//Dequeue
	assert(pq);
	assert(!QueueEmpty(pq));
	QueueNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	//鏈表為空時尾指標置空
	if (pq->head == NULL) {
		pq->tail = NULL;
	}
}

在tail所指的隊尾后再新建并鏈上一個結點，再將tail指標指向新結點，這便是入隊的原理，出隊只能在隊頭洗掉結點，也就是將head指標指向下一個結點并將前一個釋放掉即可，

head->next對頭指標解參考，就一定要保證head有next，也就是保證鏈表非空，

獲取隊頭隊尾元素
QDataType QueueFront(Queue* pq) {
	assert(pq);
    assert(!QueueEmpty(pq));
	return pq->head->data;
}
QDataType QueueBack(Queue* pq) {
	assert(pq);
    assert(!QueueEmpty(pq));
	return pq->tail->data;
}

與出堆疊的實作類似，獲取佇列元素tail->data，對指標解參考訪問其所指空間，必然要檢查指標是否有效，也就是判斷鏈表是否為空，

void test() {
    //...
    while (!QueueEmpty(&q)) {
    	printf("%d ", QueueFront(&q));
    	QueuePop(&q);
	}
}

配合上述函式可以模擬實作回圈出隊，

其他基本介面
//獲取佇列元素個數
int QueueSize(Queue* pq) {
	assert(pq);
	int count = 0;
	QueueNode* cur = pq->head;
	while (cur) {
		count++;
		cur = cur->next;
	}
	return count;
}
//檢測佇列是否為空
bool QueueEmpty(Queue* pq) {
	assert(pq);
	return !pq->head;
}

獲取佇列元素個數，除了遍歷計數的方式，還可以定義一個整型變數放在結點結構體中，

3 堆疊和佇列面試題

Example 1 判斷有效括號

判斷有效括號

給定一個只包括 (,),{,},[,] 的字串 s ，判斷字串是否有效，

bool isValid(char* s) {
    ST st;
    StackInit(&st); 
    while (*s) {
        if (*s == '(' || *s == '[' || *s == '{') {
            StackPush(&st, *s);
        }
        else {
            //堆疊無元素，無法與右括號匹配  
            if (StackEmpty(&st)) {
                StackDestroy(&st);
                return false;
            }
            STDataType ret = StackTop(&st);
            if ((ret == '(' && *s != ')') || (ret == '[' && *s != ']') || (ret == '{' && *s != '}')) {
                StackDestroy(&st);
                return false;
            }
            else {
                StackPop(&st);            
            }
        }
        s++;
    }
    if (StackEmpty(&st)) {
        StackDestroy(&st);
        return true;
    }
    else {
        StackDestroy(&st);
        return false;
    }
}

利用堆疊的先進后出，后進先出的特點，

  1. 將字串s從前向后遍歷將其中所有左括號依次入堆疊，
  2. 等待遇到右括號時再利用后進先出的特點就可將最近的左括號與右括號對比，
  3. 若匹配成功則出堆疊一次，下一次就可以找到前一個左括號與之后的右括號進行匹配，

Example 2 佇列實作堆疊

佇列實作堆疊

使用兩個佇列實作一個后入先出的堆疊，并支持普通堆疊的全部四種操作（push、top、pop 和 empty）

如用陣列用鏈表實作，換成用佇列實作堆疊，即利用佇列的結構和介面函式，也就是佇列的特點實作出一個結構，該結構具有堆疊的特點，

/**
 * 結構體定義
 **/
typedef struct QueueNode {
	QDataType data;
	struct QueueNode* next;
}QueueNode;
typedef struct Queue {
	struct QueueNode* head;
	struct QueueNode* tail;
}Queue;
typedef struct {
	Queue q1;
	Queue q2;
} MyStack;


/**
 * 介面函式定義
 **/
MyStack* myStackCreate() {
	MyStack* st = (MyStack*)malloc(sizeof(MyStack));
	if (st == NULL) {
		exit(-1);
	}    
	QueueInit(&st->q1);
	QueueInit(&st->q2);
	return st;
}
//呼叫函式創建堆區結構體并回傳

void myStackPush(MyStack* obj, int x) {
	assert(obj);
	//向非空佇列Push
	if (!QueueEmpty(&obj->q1)) {
		QueuePush(&obj->q1, x);
	}
	else {
		QueuePush(&obj->q2, x);
	}
}

int myStackPop(MyStack* obj) {
	assert(obj);
    //定義空與非空佇列
	Queue* emptyQ = &obj->q1;
	Queue* nonEmptyQ = &obj->q2;
	if (!QueueEmpty(&obj->q1)) {
		nonEmptyQ = &obj->q1;
		emptyQ = &obj->q2;
	}
	//將非空佇列前n-1個元素Push到空佇列
	while (QueueSize(nonEmptyQ) > 1) {
		QueuePush(emptyQ, QueueFront(nonEmptyQ));
		QueuePop(nonEmptyQ);
	}
	//Pop最后一個元素并回傳
	int top = QueueFront(nonEmptyQ);
	QueuePop(nonEmptyQ);
	return top;
}

int myStackTop(MyStack* obj) {
	assert(obj);
    //回傳非空佇列隊尾元素
	if (!QueueEmpty(&obj->q1)) {
		return QueueBack(&obj->q1);
	}
	else {
		return QueueBack(&obj->q2);
	}
}

bool myStackEmpty(MyStack* obj) {
	assert(obj);
    //二者皆空才為空
	return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
	assert(obj);
    //釋放佇列結點
	QueueDestroy(&obj->q1);
	QueueDestroy(&obj->q2);
	//釋放結構體
    free(obj);
}
  1. Push，由于堆疊和佇列都是從固定的一端入，故模擬入堆疊直接向非空佇列入即可，

  1. Pop，模擬出堆疊時，就要考慮到二者的不同，先洗掉佇列中的前 n ? 1 n-1 n?1個元素并將其入到另一個空佇列中，直至第 n n n個元素再將其洗掉，

隊頭出資料，隊尾入資料，正好能將非空佇列前 n n n個元素按照原順序插入到空佇列中，非空佇列僅剩最后一個元素再洗掉掉，將所插佇列視為出堆疊后的堆疊，便實作模擬出堆疊的程序，

  1. Top，直接呼叫佇列讀取隊尾元素的介面函式即可，

完成任意操作后都會產生一個空佇列和一個非空佇列，通過加以判斷可以將非空佇列視為待操作物件，也就是每次操作都是操作非空佇列，

Example 3 堆疊實作佇列

堆疊實作佇列

使用兩個堆疊實作先入先出佇列，佇列應當支持一般佇列支持的所有操作（push、pop、peek、empty）

/**
 * 結構體定義
 **/
typedef int STDataType;
typedef struct Stack {
	STDataType* a;
	int top;
	int capacity;
}ST;
typedef struct {
    ST pushST;
    ST popST;
} MyQueue;


/**
 * 介面函式定義
 **/
MyQueue* myQueueCreate() {
    MyQueue* pq= (MyQueue*)malloc(sizeof(MyQueue));
    if (pq == NULL) {
        exit(-1);
    }
    StackInit(&pq->pushST);
    StackInit(&pq->popST);
    return pq;
}

void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->pushST, x);
}

int myQueuePop(MyQueue* obj) {
    //出堆疊為空，將入堆疊所有元素移到出堆疊
    if (StackEmpty(&obj->popST)) {
        while (!StackEmpty(&obj->pushST)) {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    //洗掉堆疊頂即隊頭元素
    int front = StackTop(&obj->popST);
    StackPop(&obj->popST);
    return front;
}

int myQueuePeek(MyQueue* obj) {
    //出堆疊為空，將入堆疊所有元素移到出堆疊
    if (StackEmpty(&obj->popST)) {
        while (!StackEmpty(&obj->pushST)) {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    //回傳堆疊頂即隊頭元素
    return StackTop(&obj->popST);
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushST) && StackEmpty(&obj->popST);
}

void myQueueFree(MyQueue* obj) {
	free(&obj->pushST);
    free(&obj->popST);
    free(obj);
}

由于堆疊的特點后進先出，將堆疊中元素移入另一個堆疊中會造成“逆置”的現象，此時將元素插入到非空堆疊中會導致順序發生錯誤，故指定兩個堆疊分別為入堆疊pushST和出堆疊popST，分別負責入堆疊和出堆疊，

  1. Push，將直接將元素插入到負責入堆疊的pushST中，

  1. Pop，popST為空，就將pushST的元素移到popST，再從popST堆疊頂出堆疊就等于洗掉pushST的堆疊底元素，

將元素從“入堆疊”移到“出堆疊”，等于將元素逆置，逆置后的堆疊出堆疊操作而言已然和佇列的出隊一樣，相當于將堆疊底的元素從堆疊底出堆疊，也就是從先進后出變成先進先出，模擬實作了出隊，

入堆疊pushST和出堆疊popST互不影響，分別完成入隊的出隊的任務，只要popST為空，就將pushST中元素移入即可，

Example 4 實作回圈佇列

實作回圈佇列

回圈佇列可由陣列和鏈表兩種方式實作，陣列則是通過下標回圈，鏈表是回圈鏈表，

  1. 回圈佇列同樣是佇列，滿足佇列的所有性質，
  2. 回圈佇列空間大小固定且可重復利用，
  3. 需要多開辟一個元素的空間以用于判滿，

由圖可得tail->next==head即佇列滿，tail==head即佇列空，陣列利用下標控制即可，利多開一塊的空間來判滿，

陣列實作
/**
 * 結構體定義
 **/
typedef struct {
    int* a;
    int front;
    int tail;
    int k;
} MyCircularQueue;
/**
 * 介面函式定義
 **/
MyCircularQueue* myCircularQueueCreate(int k) {
    //為結構體開辟空間
    MyCircularQueue* cq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    //開辟陣列
	cq->a = (int*)malloc((k + 1) * sizeof(int));
    cq->k = k;
    cq->front = cq->tail = 0;
    return cq;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    assert(obj);
    //插入判斷非滿
    if (myCircularQueueIsFull(obj)) {
        return false;
    }
    obj->a[obj->tail] = value;
    obj->tail++;
    //回到陣列中對應位置
    obj->tail %= obj->k + 1;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    assert(obj);
    //洗掉判斷非空
    if (myCircularQueueIsEmpty(obj)) {
        return false;
    }
    obj->front++;
    obj->front %= obj->k + 1;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    assert(obj);
    if (myCircularQueueIsEmpty(obj)) {
        return -1;
    }
    return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    assert(obj);
    if (myCircularQueueIsEmpty(obj)) {
        return -1;
    }
    /*
    if (obj->tail == 0) 
        return obj->a[obj->k];
    else
    	return obj->a[obj->tail - 1];
    */
    int i = (obj->tail + obj->k) % (obj->k + 1);
    return obj->a[i];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    assert(obj);
    return obj->front == obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    assert(obj);
    /*
    if (obj->tail == obj->k) 
        return obj->front == 0;
    else 
        return obj->tail + 1 == obj->front;
    */
    return obj->tail % (obj->k + 1) == obj->front; 
    //tail % (K + 1) + 1 == front
}

void myCircularQueueFree(MyCircularQueue* obj) {
    assert(obj);
    free(obj->a);
    free(obj);
}

陣列實作，必須要考慮下標溢位的問題，當下標在陣列內時，模等上陣列長度其值不受影響，當下標溢位時，模等上陣列長度就回到陣列內對應位置，

下標溢位幾個單位，模等陣列長度后就會回到陣列內第幾位，

鏈表實作
/**
 * 結構體定義
 **/
typedef int SLTDataType;

typedef struct SLTNode {
	SLTDataType data;
	struct SLTNode* next;
}SLTNode;

typedef struct {
	SLTNode* head;
	SLTNode* tail;
	int k;
} MyCircularQueue;
/**
 * 介面函式定義
 **/
MyCircularQueue* myCircularQueueCreate(int k) {
	MyCircularQueue* pq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	if (pq == NULL)
		exit(-1);
 	pq->k = k;
	//開辟鏈表
	pq->head = SListNewNode();
	pq->tail = pq->head;
	while (k--) {
		pq->tail->next = SListNewNode();
		pq->tail = pq->tail->next;
	}
	//頭尾相連
	pq->tail->next = pq->head;
	//初始化指標
	pq->tail = pq->head;
	
	return pq;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
	assert(obj);
	if (myCircularQueueIsFull(obj)) {
		return false;
	}
	SListInsert(obj->tail, value);
	obj->tail = obj->tail->next;
	return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
	assert(obj);
	if (myCircularQueueIsEmpty(obj)) {
		return false;
	}
	obj->head = obj->head->next;
	return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
	assert(obj);
	if (myCircularQueueIsEmpty(obj)) {
		return -1;
	}
	return obj->head->data;
}

int myCircularQueueRear(MyCircularQueue* obj) {
	assert(obj);
	if (myCircularQueueIsEmpty(obj)) {
		return -1;
	}
	SLTNode* cur = obj->head;
	while (cur->next != obj->tail) {
		cur = cur->next;
	}
	return cur->data;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
	assert(obj);
	return obj->head == obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
	assert(obj);
	return obj->tail->next == obj->head;
}

void myCircularQueueFree(MyCircularQueue* obj) {
	assert(obj);
	SLTNode* cur = obj->head;
	while (cur->next != obj->head) {
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(cur);
	free(obj);
}

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

標籤：其他

上一篇：【資料結構】堆

下一篇：資料結構：線性表順序表以及單鏈表詳解

標籤雲
其他(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 有解無憂