2. 程式人生 > >佇列的基本操作（順序佇列、迴圈佇列、鏈式佇列）

佇列的基本操作（順序佇列、迴圈佇列、鏈式佇列）

阿新 • • 發佈：2019-01-15

        佇列也是一種線性表，是一種先進先出的線性結構。佇列只允許在表的一端進行插入（入隊）、刪除（出隊）操作。允許插入的一端稱為隊尾，允許刪除的一端稱為隊頭。
       佇列的基本操作包括：

  • 初始化佇列：InitQueue（Q）
       操作前提：Q為未初始化的佇列。
       操作結果：將Q初始化為一個空佇列。
  • 判斷佇列是否為空：IsEmpty（Q）
       操作前提：佇列Q已經存在。
       操作結果：若佇列為空則返回1，否則返回0。
  • 判斷佇列是否已滿：IsFull（Q）
       操作前提：佇列Q已經存在。
       操作結果：若佇列為滿則返回1，否則返回0。
  • 入隊操作：EnterQueue（Q，data）
       操作前提：佇列Q已經存在。
       操作結果：在佇列Q的隊尾插入data。
  • 出隊操作：DeleteQueue（Q，&data）
       操作前提：佇列Q已經存在且非空。
       操作結果：將佇列Q的隊頭元素出隊，並使用data帶回出隊元素的值。
  • 取隊首元素：GetHead（Q，&data）
       操作前提：佇列Q已經存在且非空。
       操作結果：若佇列為空則返回1，否則返回0。
  • 清空佇列：ClearQueue(&Q)
       操作前提：佇列Q已經存在。
       操作結果：將Q置為空佇列。

       佇列有兩種儲存形式：順序儲存和鏈式儲存。採用順序佇列儲存的佇列稱為順序佇列，採用鏈式儲存的佇列稱為鏈式佇列。順序佇列採用陣列儲存佇列中的元素，使用兩個指標尾指標(rear)和頭指標（front）分別指向佇列的隊頭和隊尾。使用順序佇列由於在操作時會出現“假溢位現象”，所以可以使用順序迴圈佇列合理的使用佇列空間。鏈式佇列使用連結串列來實現，連結串列中的資料域用來存放佇列中的元素，指標域用來存放佇列中下一個元素的地址，同時使用隊頭指標指向佇列的第一個元素和最後一個元素。

順序佇列的基本操作

/*----------------------------------------------------------------
設立一個隊首指標front ，一個隊尾指標rear ，分別指向隊首和隊尾元素。

 ◆ 初始化：front=rear=0。
 ◆ 佇列為空：front=rear。
 ◆ 隊滿：rear=MaxSize。
 ◆ 入隊：將新元素插入rear所指的位置，然後rear加1。
 ◆ 出隊：刪去front所指的元素，然後加1並返回被刪元素。
 ◆ 取隊首元素：返回fornt指向的元素值
 -----------------------------------------------------------------*/
 


#include <stdio.h>
#include <assert.h>
#include <Windows.h>

#define MaxSize 10  //佇列的最大容量

typedef int DataType;  //佇列中元素型別
typedef struct Queue
{
    DataType Queue[MaxSize];
    int fornt;   //隊頭指標
    int rear;    //隊尾指標
}SeqQueue;

//佇列初始化，將佇列初始化為空佇列
void InitQueue(SeqQueue *SQ)
{
    SQ->fornt = SQ->rear = 0;  //把對頭和隊尾指標同時置0
 }

//判斷佇列為空

int IsEmpty(SeqQueue* SQ)
{
    if (SQ->fornt == SQ->rear)
    {
        return 1;
    }
    return 0;
}

//判斷佇列是否為滿

int IsFull(SeqQueue* SQ)
{
    if (SQ->rear == MaxSize) 
    {
        return 1;
    }
    return 0;
}

//入隊,將元素data插入到佇列SQ中

void EnterQueue(SeqQueue* SQ,DataType data)
{
    if (IsFull(SQ))
    {
        printf("佇列已滿\n");
        return 0;
    }
    SQ->Queue[SQ->rear] = data;  //在隊尾插入元素data
    SQ->rear = SQ->rear + 1;     //隊尾指標後移一位
}

//出隊，將佇列中隊頭的元素data出隊，出隊後隊頭指標front後移一位
int DeleteQueue(SeqQueue* SQ,DataType* data)
{
    if (IsEmpty(SQ))
    {
        printf("佇列為空！\n");
        return 0;
    }
    *data = SQ->Queue[SQ->fornt];   //出隊元素值
    SQ->fornt = (SQ->fornt)+1;      //隊尾指標後移一位
    return 1;
}

//獲取隊首元素

int GetHead(SeqQueue* SQ,DataType* data)
{
    if (IsEmpty(SQ))
    {
        printf("佇列為空!\n");
    }
    return *data = SQ->Queue[SQ->fornt];  
}

//清空佇列

void ClearQueue(SeqQueue* SQ)
{
    SQ->fornt = SQ->rear = 0;
}

//列印佇列中的與元素

void PrintQueue(SeqQueue* SQ)
{
    assert(SQ);    
    int i = SQ->fornt;
    while(i<SQ->rear)
    {
        printf("%-3d", SQ->Queue[i]);
        i++;
    }
    printf("\n");
}
int main()
{
    SeqQueue SQ;
    DataType data;
    //初始化佇列
    InitQueue(&SQ);
    //入隊
    EnterQueue(&SQ, 1);
    EnterQueue(&SQ, 2);
    EnterQueue(&SQ, 3);
    EnterQueue(&SQ, 4);
    EnterQueue(&SQ, 5);
    EnterQueue(&SQ, 6);
    EnterQueue(&SQ, 8);
    EnterQueue(&SQ, 10);
    EnterQueue(&SQ, 12);
    EnterQueue(&SQ, 15);
    EnterQueue(&SQ, 16);

    //列印佇列中的元素
    printf("佇列中的元素為：");
    PrintQueue(&SQ);
    printf("\n");
    //出隊
    DeleteQueue(&SQ, &data);
    printf("出隊元素為：%d\n", data);
    printf("\n");
    DeleteQueue(&SQ, &data);
    printf("出隊元素為：%d\n", data);
    printf("\n");
    printf("佇列中的元素為：");
    PrintQueue(&SQ);
    printf("\n");
    //獲取隊首元素
    data = GetHead(&SQ, &data);
    printf("隊首元素為：%d\n", data);
    printf("#元素16入隊#\n");
    //元素16入隊
    EnterQueue(&SQ, 16);
    printf("佇列中的元素為：");
    PrintQueue(&SQ);
    printf("\n");
    system("pause");
    return 0;
}

測試結果

佇列已滿
佇列中的元素為：1 2 3 4 5 6 8 10 12 15

出隊元素為：1

出隊元素為：2

佇列中的元素為：3 4 5 6 8 10 12 15

隊首元素為：3
/#元素16入隊#
佇列已滿
佇列中的元素為：3 4 5 6 8 10 12 15

請按任意鍵繼續…

        在上面的程式碼裡，我們定義的佇列的最大容量為：10，依此呼叫入隊函式EnterQueue，將1，2，3，4，5，6，8，10，12，15，16總共11個元素依此入隊，我們看到執行結果最先輸出佇列已滿，這是因為16入隊時，佇列以達到最大容量，所以，輸出提示資訊“佇列已滿”，列印佇列中的元素結果入第二行1，2，3，4，5，6，8，10，12，15。然後依此測試了出隊，取隊首元素等函式，仔細觀察，可以發現在測試出隊時，依此出隊兩次，此時列印佇列中的元素值為3，4，5，6，8，10，12，15總共8個元素值。我們定義的佇列的最大容量為10，出隊兩次後佇列中的元素個數為8，則佇列中還有兩個空間，但再次執行入隊操作EnterQueue(&SQ, 16); 發現並沒有將16成功入隊，而是輸出提示“佇列已滿”，再次列印佇列中的元素，發現佇列中依然只有8個元素。這時怎麼回事兒呢？其實這就是文章前邊提到的順序佇列的“假溢位現象”。
        所謂假溢位現象，即隊頭由於出隊操作，還有剩餘空間，但隊尾指標已達到陣列的末尾，如果繼續插入元素，隊尾指標就會越出陣列的上界，而造成“溢位”，這種溢位不是因為儲存空間不夠而產生的溢位，而是經過多次插入刪除操作引起的，像這中有儲存空間而不能插入元素的操作稱為“假溢位“。可以通過下面的圖爿理解假溢位。
這裡寫圖片描述

        為了充分利用儲存空間，消除這種”假溢位”,可以採用的方法是：將為佇列分配的空間看成為一個首尾相接的圓環，並稱這種佇列為迴圈佇列。
        在迴圈佇列中進行出隊、入隊操作時，隊首、隊尾指標仍要加1，指標移動。只不過當隊頭指標front 指向向量上界(MaxSize-1)時，其加1操作的結果是指向向量的下界0。
這種迴圈意義下的加1操作可以描述為：

if  (i+1==MaxSize)   i=0;
else     i++ ;

        其中： i代表隊首指標front（出隊時）；或隊尾指標rear（入隊時），用模運算可簡化為：i=(i+1)%MaxSize ;顯然，迴圈佇列所分配的空間可以被充分利用，除非向量空間真的被佇列元素全部佔用，否則不會上溢。
        迴圈佇列在隊空和隊滿時，都是隊頭指標和隊尾指標指向同一個位置，即：front==rear 為了區分這兩種情況，可以少用一個儲存空間，隊空的判斷條件不變，以隊尾指標rear加1等於隊頭指標為佇列的判滿條件。即：front = rear 表示隊空，（rear + 1) % MaxSize == fornt 表示隊滿。

迴圈佇列的基本操作

/*----------------------------------------------------------------
設立一個隊首指標front ，一個隊尾指標rear ，分別指向隊首和隊尾元素。

◆ 初始化：front=rear=0。
◆ 佇列為空：front=rear。
◆ 隊滿：（rear + 1) % MaxSize == fornt
◆ 入隊：將新元素插入rear所指的位置，然後rear加1。
◆ 出隊：刪去front所指的元素，然後加1並返回被刪元素。
◆ 取隊首元素：返回fornt指向的元素值
-----------------------------------------------------------------*/

#include<stdio.h>
#include<Windows.h>
#include<assert.h>

#define MaxSize 10
typedef int DataType;
typedef struct SeqQueue
{
    DataType Queue[MaxSize];
    int fornt;
    int rear;
}SeqCirQueue;

//佇列初始化

void InitSeqCirQueue(SeqCirQueue* SCQ)
{
    SCQ->fornt = SCQ->rear = 0;
}

//判斷佇列是否為空
int IsEmpty(SeqCirQueue* SCQ)
{
    if (SCQ->fornt == SCQ->rear)
    {
        return 1;
    }
    return 0;
}

//判斷佇列是否為滿
int IsFull(SeqCirQueue* SCQ)
{
    //尾指標+1追上隊頭指標，標誌佇列已經滿了
    if ((SCQ->rear + 1) % MaxSize == SCQ->fornt)
    {
        return 1;
    }
    return 0;
}

//入隊操作
int EnterSeqCirQueue(SeqCirQueue* SCQ, DataType data)
{
    if (IsFull(SCQ))
    {
        printf("佇列已滿，不能入隊！\n");
        return 0;
    }
    SCQ->Queue[SCQ->rear] = data;
    SCQ->rear = (SCQ->rear + 1) % MaxSize;   //重新設定隊尾指標
}


//出隊操作
int DeleteSeqCirQueue(SeqCirQueue* SCQ,DataType* data)
{
    if (IsEmpty(SCQ))
    {
        printf("佇列為空！\n");
        return 0;
    }
    *data = SCQ->Queue[SCQ->fornt];
    SCQ->fornt = (SCQ->fornt + 1) % MaxSize;  //重新設定隊頭指標
}

//取隊首元素
int GetHead(SeqCirQueue* SCQ,DataType* data)
{
    if (IsEmpty(SCQ))
    {
        printf("佇列為空！\n");
        return 0;
    }
    *data = SCQ->Queue[SCQ->fornt];
    return *data;
}

//清空佇列
void ClearSeqCirQueue(SeqCirQueue* SCQ)
{
    SCQ->fornt = SCQ->rear = 0;
}

//列印佇列元素
void PrintSeqCirQueue(SeqCirQueue* SCQ)
{
    assert(SCQ);   //斷言SCQ不為空
    int i = SCQ->fornt;
    if (SCQ->fornt < SCQ->rear)
    {
        for (; i < SCQ->rear; i++)
        {
            printf("%-3d", SCQ->Queue[i]);
        }
    }
    else
    {
        for (i; i <SCQ->rear + MaxSize; i++)
        {
            printf("%-3d", SCQ->Queue[i]);
        }
    }
    printf("\n");
}

int main()
{
    SeqCirQueue SCQ;
    DataType data;
    //初始化佇列
    InitSeqCirQueue(&SCQ);
    //入隊
    EnterSeqCirQueue(&SCQ, 1);
    EnterSeqCirQueue(&SCQ, 2);
    EnterSeqCirQueue(&SCQ, 4);
    EnterSeqCirQueue(&SCQ, 6);
    EnterSeqCirQueue(&SCQ, 8);
    EnterSeqCirQueue(&SCQ, 9);
    EnterSeqCirQueue(&SCQ, 10);
    EnterSeqCirQueue(&SCQ, 12);
    EnterSeqCirQueue(&SCQ, 13);
    printf("佇列中元素為：\n");
    //列印佇列中元素
    PrintSeqCirQueue(&SCQ);
    EnterSeqCirQueue(&SCQ, 15);
    //出隊
    DeleteSeqCirQueue(&SCQ, &data);
    printf("出隊元素為：%d\n", data);
    printf("\n");
    printf("佇列中元素為：\n");
    PrintSeqCirQueue(&SCQ);
    printf("15入隊：\n");
    EnterSeqCirQueue(&SCQ, 15);
    printf("佇列中元素為：\n");
    PrintSeqCirQueue(&SCQ);
    system("pause");
    return 0;
}

測試結果

佇列中元素為：
1 2 4 6 8 9 10 12 13
佇列已滿，不能入隊！
出隊元素為：1

佇列中元素為：
2 4 6 8 9 10 12 13
15入隊：
佇列中元素為：
2 4 6 8 9 10 12 13 15
請按任意鍵繼續…

        為了區分隊空和隊滿的條件，少用了一個儲存空間，所以佇列的實際儲存空間為9，當入隊9個元素時，再入隊顯示佇列已滿，當出隊一個元素後，佇列中剩餘一個儲存空間，我們執行入隊操作，成功將元素15入隊，從而消除了”假溢位現象“。

        佇列的鏈式儲存結構簡稱為鏈式佇列，它是限制僅在表頭進行刪除操作和表尾進行插入操作的單鏈表。鏈隊的操作實際上是單鏈表的操作，只不過是出隊在表頭進行，入隊在表尾進行。入隊、出隊時分別修改不同的指標。鏈式佇列的出隊和入隊的操作可參考下圖：
這裡寫圖片描述

**鏈式佇列的基本操作

#include <stdio.h>
#include <Windows.h>
#include <stdlib.h>
#include <assert.h>

typedef int DataType;
typedef struct Node
{
    DataType _data;
    struct Node* _next;
}LinkQueueNode;

typedef struct
{
    LinkQueueNode* front;
    LinkQueueNode* rear;
}LinkQueue;

//初始化佇列
void InitLinkQueue(LinkQueue* LQ)
{
    //建立一個頭結點
    LinkQueueNode* pHead = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
    assert(pHead);
    LQ->front = LQ->rear = pHead; //隊頭和隊尾指向頭結點
    LQ->front->_next = NULL;
}

//判斷佇列是否為空

int IsEmpty(LinkQueue* LQ)
{
    if (LQ->front->_next == NULL)
    {
        return 1;
    }
    return 0;
}

//入隊操作

void EnterLinkQueue(LinkQueue* LQ, DataType data)
{
    //建立一個新結點
    LinkQueueNode* pNewNode = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
    assert(pNewNode);
    pNewNode->_data = data;  //將資料元素賦值給結點的資料域
    pNewNode->_next = NULL;  //將結點的指標域置空
    LQ->rear->_next = pNewNode;   //將原來佇列的隊尾指標指向新結點
    LQ->rear = pNewNode;      //將隊尾指標指向新結點
}

//出隊操作

void DeleteLinkQueue(LinkQueue* LQ,DataType* data)
{
    if (IsEmpty(LQ))
    {
        printf("佇列為空！\n");
        return;
    }
    //pDel指向隊頭元素，由於隊頭指標front指向頭結點，所以pDel指向頭結點的下一個結點
    LinkQueueNode* pDel = LQ->front->_next;  
    *data = pDel->_data;   //將要出隊的元素賦給data
    LQ->front->_next = pDel->_next;  //使指向頭結點的指標指向pDel的下一個結點
    //如果佇列中只有一個元素,將佇列置空
    if (LQ->rear = pDel)   
    {
        LQ->rear = LQ->front;
    }
    free(pDel);   //釋放pDel指向的空間
}

//取隊頭元素

int GetHead(LinkQueue* LQ, DataType* data)
{
    if (IsEmpty(LQ))
    {
        printf("佇列為空!\n");
        return 0;
    }
    LinkQueueNode* pCur;
    pCur = LQ->front->_next;  //pCur指向佇列的第一個元素，即頭結點的下一個結點
    *data = pCur->_data;      //將隊頭元素值賦給data
    return *data;             //返回隊頭元素值
}

//清空佇列

void ClearQueue(LinkQueue* LQ)
{
    while (LQ->front != NULL)
    {
        LQ->rear = LQ->front->_next;  //隊尾指標指向隊頭指標的下一個結點
        free(LQ->front);              //釋放隊頭指標指向的結點
        LQ->front = LQ->rear;         //隊頭指標指向隊尾指標
    }
}

//列印佇列中的元素

void PrintLinkQueue(LinkQueue* LQ)
{
    assert(LQ);
    LinkQueueNode * pCur;
    pCur = LQ->front->_next;
    while (pCur)
    {
        printf("%-3d", pCur->_data);
        pCur = pCur->_next;
    }
    printf("\n");
}
int main()
{
    LinkQueue LQ; 
    DataType data;
    //初始化佇列
    InitLinkQueue(&LQ);
    //入隊
    EnterLinkQueue(&LQ, 1); 
    EnterLinkQueue(&LQ, 2);
    EnterLinkQueue(&LQ, 3);
    EnterLinkQueue(&LQ, 4);
    EnterLinkQueue(&LQ, 5);
    EnterLinkQueue(&LQ, 6);
    EnterLinkQueue(&LQ, 7);
    EnterLinkQueue(&LQ, 8);
    printf("佇列中的元素為：");
    //列印佇列中元素
    PrintLinkQueue(&LQ);
    printf("\n");
    //取隊頭元素
    data = GetHead(&LQ, &data);
    printf("隊頭元素為：%d\n", data);
    printf("\n");
    //出隊
    DeleteLinkQueue(&LQ, &data);
    printf("出隊的元素為：%d\n", data);
    printf("\n");
    printf("佇列中的元素為：");
    PrintLinkQueue(&LQ);
    printf("\n");
    data = GetHead(&LQ, &data);
    printf("隊頭元素為：%d\n", data);
    printf("\n");
    ClearQueue(&LQ);
    system("pause");
    return 0;
}

        鏈式佇列的結點是動態開闢的，入隊時，為新節點開闢空間，出隊使釋放出隊元素結點的空間。所以相對於順序佇列和迴圈佇列，鏈式佇列沒有判斷佇列是否為滿操作。但在清空佇列時需要將佇列所有結點的空間動態釋放，從而防止記憶體洩露。測試清空函式可以通過編譯器除錯來觀察。如下圖：
這裡寫圖片描述
        在執行完初始化後，開闢了一個新的結點pHead，使頭指標和尾指標都指向pHead，pHed->-next = NULL;可以看到pHead的和fornt，rear的地址相同，沒有執行入隊操作，所以他們的資料域為一個隨機值，指標域為空。
        執行完兩次入隊後：
這裡寫圖片描述
        執行完清空操作後：
這裡寫圖片描述

相關推薦

資料結構學習之路4 佇列的基本操作（順序儲存的迴圈佇列+連結串列實現）

佇列先進先出，這裡用了順序（陣列）和鏈式兩種方式實現，下次再用鏈式儲存實現以下堆疊試試 迴圈佇列： //順序儲存結構的迴圈佇列 #include<iostream> using namespace std; #define MAXSIZE 100 typedef

佇列的基本操作（順序佇列、迴圈佇列、鏈式佇列）

        佇列也是一種線性表，是一種先進先出的線性結構。佇列只允許在表的一端進行插入（入隊）、刪除（出隊）操作。允許插入的一端稱為隊尾，允許刪除的一端稱為隊頭。        佇列的基本操作包括： 初始化佇列：InitQueue（Q）

C語言_棧的基本操作（順序棧）

##本片部落格主要是順序棧的基本操作，包含以下內容： 初始化 入棧 出棧 判空 判滿 返回棧頂元素（棧頂元素不出棧） 返回棧頂元素（棧頂元素出棧） ###順序棧的初始化： 初始化順序棧時只需要讓棧頂等零 void InitStack (Stack *p) //初始化

連結串列的基本操作（插入，刪除，排序、逆置等）

連結串列是資料結構中最基本的，也是非常經典的，在面試筆試中也是經常出現的題，但是萬變不離其宗，只要掌握了基本的操作，一起盡在掌控。 特別要注意的一點是處理時千萬要把是否為頭進行判斷，做為一個特例，或者建立連結串列就先固定建立一個表頭，這樣程式碼就沒這麼多判斷了。 #i

OpenCV學習心得二：影象基本操作（建立，讀取，載入，儲存，展示）+畫素操控

課程緊張，以後儘量每節課消化後及時更新部落格以加深印象。 此次為第一節實驗課內容，為了方便，我將各個功能寫成一個小方法，在main函式裡呼叫已檢驗成功與否。 helloline()  :建立圖片 draw()  :基本作圖 pixels():操縱圖片畫素點 thr(

線段樹基本操作（單點更新，區間極值，區間求和）

做了一部分題目，總結一下線段樹的幾個基本操作。 #include<iostream> #include<cstdio> #include<cstring> #include<cstdlib> #include<algo

資料結構2--線性表（java程式碼實現線性表的鏈式儲存）

1.鏈式儲存       2.分析       每個節點為一個物件，該物件包含資料域和指標域        整條單鏈表為一個物件，他和節點物件進行組合。  3.

迴圈線性佇列的基本操作（帶實驗資料）

#include <iostream> #include <cstring> using namespace std; bool overflow=0; struct Queue { int date[300]; int head; int tail; int le

資料結構 順序佇列 迴圈佇列 基本操作

順序佇列基本操作：  #define MAXSIZE 1000 struct queue{ int front ,rear;//表示頭指標和 尾指標 int data[MAXSIZE]; //儲存資料的陣列 } void Initqueue(queue &

順序佇列基本操作的實現----入隊、出隊、列印

以順序儲存結構對佇列進行操作----入隊、出隊、列印並判斷佇列現有長度（以類的形式） 程式如下： queue.h  標頭檔案 #pragma once #include <iostream> class queue { private: int *dat

java佇列實現（順序佇列、鏈式佇列、迴圈佇列）

雙向順序佇列ArrayDeque和雙向鏈式佇列LinkedList，JDK已經包含，在此略。ArrayDeque包括順序棧和順序佇列，LinkedList包含鏈式棧和鏈式佇列。ArrayDeque和LinkedList都是執行緒不安全的。PriorityQueue優先佇列也

資料結構——線性表：順序佇列、鏈式佇列（C++）

內容概要： 佇列的相關概念 注意事項 code:佇列抽象類、順序佇列類、鏈式佇列類 一、佇列的相關概念 佇列是一種受限制的線性表，其特點是“先進先出”（FIFO）。 佇列元素只能從隊尾插入（入隊操作：enqueue）、從隊首刪除（出隊操作：deque

鏈佇列的基本操作（C++）

#pragma once //===================鏈隊=================== /*鏈佇列是基於連結串列實現的佇列:連結串列頭部為隊首，連結串列尾部為隊尾*/ template<typename T> struct QueueN

資料結構之順序佇列的操作（C語言）

#include <stdio.h> #include <stdlib.h> #include <string.h> #define QUEUELEN 15 //資料結構的定義 typedef struct { char name[

程式設計基本結構（順序、選擇、迴圈）

1、順序結構是最簡單的一種基本控制結構，它按語句出現的先後順序依次執行例：2、選擇結構    根據條件判斷是否執行相關語句（1）.if語句1）if語句格式：if(表示式)語句12）if-else語句if(表示式)語句1else 語句2先判斷表示式的邏輯值，若該表示式的邏輯值為

UFT 基本操作（描述性編程、函數、循環）

ive dial 方法 wid 基本操作 logs pan log ron 1、描述性編程 class("描述性屬性1：=值"，"描述性屬性2：=值") 如輸入姓名，使用對象屬性方法： Dialog("Login").WinEdit("Agent Name:"

3P（PS、PR、PDF編輯器Acrobat）中的基基本操作（三）

確認密碼 安全性 inf 選中 編輯器 png nbsp 打開 順序 本文介紹一些關於圖片、視頻、PDF的最常用操作： 圖像方面：旋轉、裁剪、拼接、水印（文字）、導出　　　　　軟件：Photoshop 視頻方面：剪切（拼接）、水印（文字、字幕）、導出　　　　軟件：Premi

Hadoop HDFS基本操作（ubuntu16.04 、Hadoop 3.0.3）

hdfs shell的基本操作以及hdfsWeb檢視檔案 在安裝好hadoop叢集併成功的啟動了hdfs之後，我們就可以利用hdfs對檔案進行操作了，一下是對檔案的一些基本操作 特別注意：訪問HDFS目錄時，一定要帶有/  否則命令會出錯！ hdfs基本操作 1、查詢命令

02 ndarray的屬性 、ndarray的基本操作（索引、切片、變形、連線、切分、副本）、聚合操作、矩陣操作、排序、Panda資料結構、Series建立、索引與切片、屬性與方法、運算

二、ndarray的屬性 4個必記引數： ndim：維度 shape：形狀（各維度的長度） size：總長度 dtype：元素型別 import matplotlib.pyplot as plt ndarr = plt.imread("./jin.png") plt.

佇列基本操作

佇列：只允許在一端進行插入資料操作，在另一端進行刪除資料操作的特殊線性表，佇列具有先進先出 FIFO(First In First Out) 入佇列：進行插入操作的一端稱為隊尾 出佇列：進行刪除操作的一端稱為隊頭 Queue.h #define _CRT_SECURE_NO_WARNIN