1. 全栈程序员必看首页

优先级队列(Priority Queue)「建议收藏」

全栈程序员-站长 • • 未分类 • 阅读 61

优先级队列(Priority Queue)「建议收藏」优先级队列(PriorityQueue)注：队列是一种特征为FIFO的数据结构，每次从队列中取出的是最早加入队列中的元素。但是，许多应用需要另一种队列，每次从队列中取出的应是具有最高优先权的元素，这种队列就是优先级队列(PriorityQueue)，也称为优先权队列。1.优先级队列的概念1.1优先级队列的定义优先级队列是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。

大家好，又见面了，我是你们的朋友全栈君。

优先级队列(Priority Queue)

注：队列是一种特征为FIFO的数据结构，每次从队列中取出的是最早加入队列中的元素。但是，许多应用需要另一种队列，每次从队列中取出的应是具有最高优先权的元素，这种队列就是优先级队列(Priority Queue)，也称为优先权队列。

1. 优先级队列的概念

1.1 优先级队列的定义

  • 优先级队列是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。

1.2 优先级队列的特点

  • 优先级队列是0个或多个元素的集合，每个元素都有一个优先权或值。
  • 当给每个元素分配一个数字来标记其优先级时，可设较小的数字具有较高的优先级，这样更方便地在一个集合中访问优先级最高的元素，并对其进行查找和删除操作。
  • 对优先级队列，执行的操作主要有：(1)查找，(2)插入，(3)删除。
  • 在最小优先级队列(min Priority Queue)中，查找操作用来搜索优先权最小的元素，删除操作用来删除该元素。
  • 在最大优先级队列(max Priority Queue)中，查找操作用来搜索优先权最大的元素，删除操作用来删除该元素。
  • 插入操作均只是简单地把一个新的元素加入到队列中。
  • 注：每个元素的优先级根据问题的要求而定。当从优先级队列中删除一个元素时，可能出现多个元素具有相同的优先权。在这种情况下，把这些具有相同优先权的元素视为一个先来先服务的队列，按他们的入队顺序进行先后处理。

2. 最小优先级队列的实现——基于一维数组的存储表示

2.1 最小优先级队列的类定义及其操作的实现

  • 文件：PriorityQueue.h

    
#ifndef PRIORITY_QUEUE_H_


#define PRIORITY_QUEUE_H_



#include <iostream>


#include <string>


#include <strstream>


using namespace std;

const int defaultSize = 50;

template <class T>
class PriorityQueue
{
public:
    PriorityQueue(int sz = defaultSize);        //构造函数
    ~PriorityQueue();                           //析构函数
public:
    bool getHead(T& x) const;       //读取队头(具最小优先权)的值
    bool Insert(const T& x);        //将新元素x插入到队尾
    bool RemoveMin(T& x);           //将队头元素删除 
    bool IsEmpty() const;           //判断队列是否为空
    bool IsFull() const;            //判断队列是否为满
    void MakeEmpty();               //置优先级队列为空
    int getSize() const;            //求优先级队列中元素个数
public:
    template <class T>
    friend ostream& operator<<(ostream& os, const PriorityQueue<T>& q); //输出队列元素的重载操作<<
private:
    void adjust();                  //队列调整
private:
    T *pqelements;  //存放队列元素的队列数组
    int maxSize;    //队列最大可容纳元素个数
    int count;      //当前元素个数(长度)
};

//构造函数
template <class T>
PriorityQueue<T>::PriorityQueue(int sz)
{
    cout << "$ 执行构造函数" << endl;
    if (sz >= 0)
    {
        maxSize = sz;           
        count = 0;      
        pqelements = new T[maxSize];
    }
}                       

//析构函数
template <class T>
PriorityQueue<T>::~PriorityQueue()
{
    cout << "$ 执行析构函数" << endl;
    delete[] pqelements;
    pqelements = NULL;
}   


//读取队头(具最小优先权)的值
template <class T>
bool PriorityQueue<T>::getHead(T& x) const
{
    if (true == IsEmpty())
    {
        return false;
    }
    x = pqelements[0];
    return true;
}

//将新元素x插入到队尾
template <class T>
bool PriorityQueue<T>::Insert(const T& x)
{
    if (true == IsFull())
    {
        return false;
    }
    pqelements[count++] = x;
    adjust();   //按优先权进行调整
    return true;
}

//将队头元素删除
template <class T>
bool PriorityQueue<T>::RemoveMin(T& x)
{
    if (true == IsEmpty())
    {
        return false;
    }
    x = pqelements[0];
    for (int i = 1; i < count; i++)
    {
        pqelements[i - 1] = pqelements[i];
    }
    count--;
    return true;
}

//判断队列是否为空
template <class T>
bool PriorityQueue<T>::IsEmpty() const
{
    return (0 == count) ? true : false;
}

//判断队列是否为满
template <class T>
bool PriorityQueue<T>::IsFull() const
{
    return (maxSize == count) ? true : false;
}

//置优先级队列为空
template <class T>
void PriorityQueue<T>::MakeEmpty()
{
    delete[] pqelements;
    count = 0;
    pqelements = new T[maxSize];
}

//求优先级队列中元素个数
template <class T>
int PriorityQueue<T>::getSize() const
{
    return count;
}

//输出队列元素的重载操作<<
template <class T>
ostream& operator<<(ostream& os, const PriorityQueue<T>& q)
{
    for (int i = 0; i < q.count; i++)
    {
        os << "[" << i << "]" << " : " << q.pqelements[i] << endl;
    }
    return os;
}

//队列调整
template <class T>
void PriorityQueue<T>::adjust()
{
    int i = 0;
    T temp = pqelements[count - 1];
    for (i = count - 2; i >= 0; i--)
    {
        if (pqelements[i] <= temp)
        {
            break;
        }
        pqelements[i + 1] = pqelements[i];
    }
    pqelements[i + 1] = temp;
}


#endif /* PRIORITY_QUEUE_H_ */

2.2 主函数(main函数)的实现

  • 文件：main.cpp

    
#include "PriorityQueue.h"



#define EXIT 0 //退出


#define GETHEAD 1 //读取队头(具最小优先权)的值


#define INSERT 2 //将新元素x插入到队尾


#define REMOVEMIN 3 //将队头元素删除


#define ISEMPTY 4 //判断队列是否为空


#define ISFULL 5 //判断队列是否为满


#define MAKEEMPTY 6 //置优先级队列为空


#define GETSIZE 7 //求优先级队列中元素个数


#define OPERATOR_OSTREAM 8 //输出队列元素的重载操作<<


void print_description()
{
    cout << "------------------------------>优先级队列<------------------------------" << endl;
    cout << "功能选项说明：" << endl;
    cout << "#0： 退出" << endl;
    cout << "#1： 读取队头(具最小优先权)的值" << endl;
    cout << "#2： 将新元素x插入到队尾" << endl;
    cout << "#3： 将队头元素删除" << endl;
    cout << "#4： 判断队列是否为空" << endl;
    cout << "#5： 判断队列是否为满" << endl;
    cout << "#6： 置优先级队列为空" << endl;
    cout << "#7： 求优先级队列中元素个数" << endl;
    cout << "#8： 输出队列元素的重载操作<<" << endl;
    cout << "--------------------------------------------------------------------" << endl;
}

//判断输入的字符串每个字符是否都是数值0~9
bool IsNumber(const string& s_num)
{
    for (size_t i = 0; i < s_num.size(); i++)
    {
        if ((s_num[i] < '0') || (s_num[i] > '9'))
        {
            return false;
        }
    }
    return true;
}

//类型转换——将string型转为模板类型T
template <class T>
T StrToTtype(const string& s_num)
{
    T n_num;
    strstream ss_num;
    ss_num << s_num;
    ss_num >> n_num;
    return n_num;
}

//输入数据值
template <class T>
T get_data()
{
    cout << "> 请输入数据值，data = ";
    string s_data;
    cin >> s_data;
    return StrToTtype<T>(s_data);
}

//输入数组的最大长度
template <class T>
int get_maxsize()
{
    cout << "> 请输入数组的最大长度，maxsize = ";
    string s_maxsize;
    cin >> s_maxsize;
    while (false == IsNumber(s_maxsize))
    {
        cout << "* 输入有误，请重新输入：";
        cin >> s_maxsize;
    }
    return atoi(s_maxsize.c_str());
}

//构造优先级队列
template <class T>
PriorityQueue<T>* construct_priorityqueue()
{
    cout << "\n==> 创建优先级队列" << endl;
    int n_maxsize = get_maxsize<T>();
    PriorityQueue<T> *priorityQueue = new PriorityQueue<T>(n_maxsize);
    return priorityQueue;
}

//析构优先级队列
template <class T>
void destory_priorityqueue(PriorityQueue<T>* priorityQueue)
{
    cout << "\n==> 释放优先级队列在堆中申请的空间，并将指向该空间的指针变量置为空" << endl;
    delete priorityQueue;
    priorityQueue = NULL;
}

//读取队头(具最小优先权)的值
template <class T>
void gethead(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行读取队头(具最小优先权)的值函数" << endl;
    T data;
    if (false == priorityQueue->getHead(data))
    {
        cout << "* 读取队头元素失败" << endl;
        return;
    }
    cout << "* 读取队头元素成功，data = " << data << endl;
}

//将新元素x插入到队尾
template <class T>              
void insert(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行将新元素x插入到队尾函数" << endl;
    T data = get_data<T>();
    if (false == priorityQueue->Insert(data))
    {
        cout << "* 入队失败" << endl;
        return;
    }
    cout << "* 入队成功，data = " << data << endl;
}

//将队头元素删除
template <class T>  
void removemin(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行将队头元素删除函数" << endl;
    T data;
    if (false == priorityQueue->RemoveMin(data))
    {
        cout << "* 出队失败" << endl;
        return;
    }
    cout << "* 出队成功，data = " << data << endl;
}

//判断队列是否为空
template <class T>  
void isempty(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行判断队列是否为空函数，IsEmpty = " << priorityQueue->IsEmpty() << endl;
}

//判断队列是否为满
template <class T>  
void isfull(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行判断队列是否为满函数，IsFull = " << priorityQueue->IsFull() << endl;
}

//置优先级队列为空
template <class T>
void makeempty(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行置优先级队列为空函数" << endl;
    priorityQueue->MakeEmpty();
}

//求优先级队列中元素个数
template <class T>  
void getsize(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行求优先级队列中元素个数函数，Size = " << priorityQueue->getSize() << endl;
}

//输出队列元素的重载操作<<
template <class T>
void operator_ostream(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行输出队列元素的重载操作<<函数" << endl;
    cout << *priorityQueue;//或operator<<(cout, *priorityQueue);
}

//优先级队列操作选择
template <class T>
void select_operation(PriorityQueue<T>* priorityQueue)
{
    if (NULL == priorityQueue)
    {
        cout << "* 没有构造优先级队列，请先构造优先级队列。" << endl;
        return;
    }

    string s_operation;
    while (s_operation != "0")
    {
        cout << "\n==> 请输入功能选项编号(按\"0\"退出程序)：";
        cin >> s_operation;
        while (false == IsNumber(s_operation))
        {
            cout << "* 输入有误，请重新输入：";
            cin >> s_operation;
        }
        int n_operation = atoi(s_operation.c_str());
        switch (n_operation)
        {
            case EXIT://退出
            {
                cout << "$ 退出程序" << endl;
                break;
            }
            case GETHEAD://读取队头(具最小优先权)的值
            {
                gethead(priorityQueue);
                break;
            }
            case INSERT://将新元素x插入到队尾
            {
                insert(priorityQueue);
                break;
            }
            case REMOVEMIN://将队头元素删除
            {
                removemin(priorityQueue);
                break;
            }
            case ISEMPTY://判断队列是否为空
            {
                isempty(priorityQueue);
                break;
            }
            case ISFULL://判断队列是否为满
            {
                isfull(priorityQueue);
                break;
            }
            case MAKEEMPTY://置优先级队列为空
            {
                makeempty(priorityQueue);
                break;
            }
            case GETSIZE://求优先级队列中元素个数
            {
                getsize(priorityQueue);
                break;
            }
            case OPERATOR_OSTREAM://输出队列元素的重载操作<<
            {
                operator_ostream(priorityQueue);
                break;
            }
            default:
            {
                cout << "* 请输入正确的功能选项编号" << endl;
                break;
            }
        }
    }
}

int main(int argc, char* argv[])
{
    print_description();
    PriorityQueue<int> *priorityQueue = construct_priorityqueue<int>();
    select_operation(priorityQueue);
    destory_priorityqueue(priorityQueue);
    system("pause");
    return 0;
}

3. 最小优先级队列的实现——基于单链表的存储表示

3.1 最小优先级队列的类定义及其操作的实现

  • 文件：PriorityQueue.h

    
#ifndef PRIORITY_QUEUE_H_


#define PRIORITY_QUEUE_H_



#include <iostream>


#include <string>


#include <strstream>


using namespace std;

template <class T>
struct LinkNode         //链表结点类的定义
{
    T data;             //数据域
    LinkNode<T> *link;  //指针域——后继指针
    //仅初始化指针成员的构造函数
    LinkNode(LinkNode<T>* ptr = NULL){ link = ptr; }
    //初始化数据与指针成员的构造函数
    LinkNode(const T& value, LinkNode<T>* ptr = NULL){ data = value; link = ptr; }
};

template <class T>
class PriorityQueue
{
public:
    PriorityQueue();                //构造函数
    ~PriorityQueue();               //析构函数
public:
    bool getHead(T& x) const;       //读取队头(具最小优先权)的值
    bool Insert(const T& x);        //将新元素x插入到队尾
    bool RemoveMin(T& x);           //将队头元素删除 
    bool IsEmpty() const;           //判断队列是否为空
    bool IsFull() const;            //判断队列是否为满
    void MakeEmpty();               //置优先级队列为空
    int getSize() const;            //求优先级队列中元素个数
public:
    template <class T>
    friend ostream& operator<<(ostream& os, const PriorityQueue<T>& q); //输出队列中元素的重载操作<<
private:
    void adjust(LinkNode<T> *newNode);  //队列调整
private:
    LinkNode<T> *front; //队头指针，即链头指针
};

//构造函数
template <class T>
PriorityQueue<T>::PriorityQueue()
: front(NULL)
{
    cout << "$ 执行构造函数" << endl;
}                       

//析构函数
template <class T>
PriorityQueue<T>::~PriorityQueue()
{
    cout << "$ 执行析构函数" << endl;
    MakeEmpty();
}   

//读取队头(具最小优先权)的值
template <class T>
bool PriorityQueue<T>::getHead(T& x) const
{
    if (true == IsEmpty())
    {
        return false;
    }
    x = front->data;
    return true;
}

//将新元素x插入到队尾
template <class T>
bool PriorityQueue<T>::Insert(const T& x)
{
    LinkNode<T> *newNode = new LinkNode<T>(x);
    if (NULL == newNode)
    {
        return false;
    }

    if (NULL == front)
    {
        front = newNode;
        return true;
    }
    adjust(newNode);
    return true;
}

//将队头元素删除
template <class T>
bool PriorityQueue<T>::RemoveMin(T& x)
{
    if (true == IsEmpty())
    {
        return false;
    }
    LinkNode<T> *curNode = front;
    front = front->link;
    x = curNode->data;
    delete curNode;
    return true;
}

//判断队列是否为空
template <class T>
bool PriorityQueue<T>::IsEmpty() const
{
    return (NULL == front) ? true : false;
}

//判断队列是否为满
template <class T>
bool PriorityQueue<T>::IsFull() const
{
    return false;
}

//置优先级队列为空
template <class T>
void PriorityQueue<T>::MakeEmpty()
{
    LinkNode<T> *curNode = NULL;
    while (NULL != front)           //当链表不为空时，删去链表中所有结点
    {
        curNode = front;            //保存被删结点
        front = curNode->link;      //被删结点的下一个结点成为头结点
        delete curNode;             //从链表上摘下被删结点
    }
}

//求优先级队列中元素个数
template <class T>
int PriorityQueue<T>::getSize() const
{
    int count = 0;
    LinkNode<T> *curNode = front;
    while (NULL != curNode)
    {
        curNode = curNode->link;
        count++;
    }
    return count;
}

//输出队列中元素的重载操作<<
template <class T>
ostream& operator<<(ostream& os, const PriorityQueue<T>& q)
{
    int i = 0;
    LinkNode<T> *curNode = q.front;
    while (NULL != curNode)
    {
        os << "[" << i++ << "]" << " : " << curNode->data << endl;
        curNode = curNode->link;
    }
    return os;
}

//队列调整
template <class T>
void PriorityQueue<T>::adjust(LinkNode<T> *newNode)
{
    LinkNode<T> *preNode = NULL;
    LinkNode<T> *curNode = front;
    while (NULL != curNode)
    {
        if (curNode->data > newNode->data)
        {
            break;
        }
        preNode = curNode;
        curNode = curNode->link;
    }

    if (preNode == NULL)
    {
        newNode->link = curNode;
        front = newNode;
    }
    else
    {
        preNode->link = newNode;
        newNode->link = curNode;
    }
}


#endif /* PRIORITY_QUEUE_H_ */

3.2 主函数(main函数)的实现

  • 文件：main.cpp

    
#include "PriorityQueue.h"



#define EXIT 0 //退出


#define GETHEAD 1 //读取队头(具最小优先权)的值


#define INSERT 2 //将新元素x插入到队尾


#define REMOVEMIN 3 //将队头元素删除


#define ISEMPTY 4 //判断队列是否为空


#define ISFULL 5 //判断队列是否为满


#define MAKEEMPTY 6 //置优先级队列为空


#define GETSIZE 7 //求优先级队列中元素个数


#define OPERATOR_OSTREAM 8 //输出队列元素的重载操作<<


void print_description()
{
    cout << "------------------------------>优先级队列<------------------------------" << endl;
    cout << "功能选项说明：" << endl;
    cout << "#0： 退出" << endl;
    cout << "#1： 读取队头(具最小优先权)的值" << endl;
    cout << "#2： 将新元素x插入到队尾" << endl;
    cout << "#3： 将队头元素删除" << endl;
    cout << "#4： 判断队列是否为空" << endl;
    cout << "#5： 判断队列是否为满" << endl;
    cout << "#6： 置优先级队列为空" << endl;
    cout << "#7： 求优先级队列中元素个数" << endl;
    cout << "#8： 输出队列元素的重载操作<<" << endl;
    cout << "--------------------------------------------------------------------" << endl;
}

//判断输入的字符串每个字符是否都是数值0~9
bool IsNumber(const string& s_num)
{
    for (size_t i = 0; i < s_num.size(); i++)
    {
        if ((s_num[i] < '0') || (s_num[i] > '9'))
        {
            return false;
        }
    }
    return true;
}

//类型转换——将string型转为模板类型T
template <class T>
T StrToTtype(const string& s_num)
{
    T n_num;
    strstream ss_num;
    ss_num << s_num;
    ss_num >> n_num;
    return n_num;
}

//输入数据值
template <class T>
T get_data()
{
    cout << "> 请输入数据值，data = ";
    string s_data;
    cin >> s_data;
    return StrToTtype<T>(s_data);
}

//构造优先级队列
template <class T>
PriorityQueue<T>* construct_priorityqueue()
{
    cout << "\n==> 创建优先级队列" << endl;
    PriorityQueue<T> *priorityQueue = new PriorityQueue<T>;
    return priorityQueue;
}

//析构优先级队列
template <class T>
void destory_priorityqueue(PriorityQueue<T>* priorityQueue)
{
    cout << "\n==> 释放优先级队列在堆中申请的空间，并将指向该空间的指针变量置为空" << endl;
    delete priorityQueue;
    priorityQueue = NULL;
}

//读取队头(具最小优先权)的值
template <class T>
void gethead(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行读取队头(具最小优先权)的值函数" << endl;
    T data;
    if (false == priorityQueue->getHead(data))
    {
        cout << "* 读取队头元素失败" << endl;
        return;
    }
    cout << "* 读取队头元素成功，data = " << data << endl;
}

//将新元素x插入到队尾
template <class T>
void insert(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行将新元素x插入到队尾函数" << endl;
    T data = get_data<T>();
    if (false == priorityQueue->Insert(data))
    {
        cout << "* 入队失败" << endl;
        return;
    }
    cout << "* 入队成功，data = " << data << endl;
}

//将队头元素删除
template <class T>
void removemin(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行将队头元素删除函数" << endl;
    T data;
    if (false == priorityQueue->RemoveMin(data))
    {
        cout << "* 出队失败" << endl;
        return;
    }
    cout << "* 出队成功，data = " << data << endl;
}

//判断队列是否为空
template <class T>
void isempty(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行判断队列是否为空函数，IsEmpty = " << priorityQueue->IsEmpty() << endl;
}

//判断队列是否为满
template <class T>
void isfull(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行判断队列是否为满函数，IsFull = " << priorityQueue->IsFull() << endl;
}

//置优先级队列为空
template <class T>
void makeempty(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行置优先级队列为空函数" << endl;
    priorityQueue->MakeEmpty();
}

//求优先级队列中元素个数
template <class T>
void getsize(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行求优先级队列中元素个数函数，Size = " << priorityQueue->getSize() << endl;
}

//输出队列元素的重载操作<<
template <class T>
void operator_ostream(PriorityQueue<T>* priorityQueue)
{
    cout << "$ 执行输出队列元素的重载操作<<函数" << endl;
    cout << *priorityQueue;//或operator<<(cout, *priorityQueue);
}

//优先级队列操作选择
template <class T>
void select_operation(PriorityQueue<T>* priorityQueue)
{
    if (NULL == priorityQueue)
    {
        cout << "* 没有构造优先级队列，请先构造优先级队列。" << endl;
        return;
    }

    string s_operation;
    while (s_operation != "0")
    {
        cout << "\n==> 请输入功能选项编号(按\"0\"退出程序)：";
        cin >> s_operation;
        while (false == IsNumber(s_operation))
        {
            cout << "* 输入有误，请重新输入：";
            cin >> s_operation;
        }
        int n_operation = atoi(s_operation.c_str());
        switch (n_operation)
        {
            case EXIT://退出
            {
                cout << "$ 退出程序" << endl;
                break;
            }
            case GETHEAD://读取队头(具最小优先权)的值
            {
                gethead(priorityQueue);
                break;
            }
            case INSERT://将新元素x插入到队尾
            {
                insert(priorityQueue);
                break;
            }
            case REMOVEMIN://将队头元素删除
            {
                removemin(priorityQueue);
                break;
            }
            case ISEMPTY://判断队列是否为空
            {
                isempty(priorityQueue);
                break;
            }
            case ISFULL://判断队列是否为满
            {
                isfull(priorityQueue);
                break;
            }
            case MAKEEMPTY://置优先级队列为空
            {
                makeempty(priorityQueue);
                break;
            }
            case GETSIZE://求优先级队列中元素个数
            {
                getsize(priorityQueue);
                break;
            }
            case OPERATOR_OSTREAM://输出队列元素的重载操作<<
            {
                operator_ostream(priorityQueue);
                break;
            }
            default:
            {
                cout << "* 请输入正确的功能选项编号" << endl;
                break;
            }
        }
    }
}

int main(int argc, char* argv[])
{
    print_description();
    PriorityQueue<int> *priorityQueue = construct_priorityqueue<int>();
    select_operation(priorityQueue);
    destory_priorityqueue(priorityQueue);
    system("pause");
    return 0;
}

参考文献：
[1]《数据结构(用面向对象方法与C++语言描述)(第2版)》殷人昆——第三章
[2] 百度搜索关键字：优先级队列

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请联系我们举报，一经查实，本站将立刻删除。

发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/125280.html原文链接：https://javaforall.net

赞 (0)
全栈程序员-站长的头像全栈程序员-站长
0 0


相关推荐

  • 《提问艺术》读书笔记「建议收藏」

    《提问艺术》读书笔记「建议收藏」

    《提问艺术》读书笔记「建议收藏」内容总结：作用：获得资讯，引发深入思考，说服例子：苏格拉底我是谁的问题，爱因斯坦追上光会怎样方法：1）封闭性提问。商业工作领域常用2）开放性提问。人际交往领域常用3）追问。深入发现问题本质常用

    全栈程序员-站长的头像 全栈程序员-站长
    2022年6月23日
    24
  • pycharm如何安装依赖包_pycharm导入第三方库

    pycharm如何安装依赖包_pycharm导入第三方库

    pycharm如何安装依赖包_pycharm导入第三方库准备工作（源）：默认源：https://pypi.python.org/simple清华源：https://pypi.tuna.tsinghua.edu.cn/simple/豆瓣源：http://pypi.douban.com/simple/阿里源：https://mirrors.aliyun.com/pypi/simple/打开设置，搜索interpreter点击下方的…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年8月28日
    4
  • 守护线程与线程中断区别_守护线程和主线程

    守护线程与线程中断区别_守护线程和主线程

    守护线程与线程中断区别_守护线程和主线程1、主线程结束，守护线程也会提前结束执行。publicclassThreadDemo1extendsThread{ publicThreadDemo1(Stringname){ super(name); } @Override publicvoidrun(){ while(true){ System.err.println(getName()…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年10月10日
    3
  • python for循环语句怎么写

    python for循环语句怎么写

    python for循环语句怎么写想必大家都知道 python 循环语句吧 可以 python 循环语句有多种 比如 for 循环 while 循环 if else 等等 今天小编就给大家讲讲 for 循环语句 for 循环语句是 python 中的一个循环控制语句 任何有序的序列对象内的元素都可以遍历 比如字符串 列表 元组等可迭代对像 之前讲过的 if 语句虽然和 for 语句用法不同 但可以用在 for 语句下做条件语句使用 for 语句的基本格式 pyth

    全栈程序员-站长的头像 全栈程序员-站长
    2025年8月10日
    2
  • Intellij IDEA 查找接口实现类的快捷键「建议收藏」 idea

    Intellij IDEA 查找接口实现类的快捷键「建议收藏」

    Intellij IDEA 查找接口实现类的快捷键「建议收藏」查找接口的实现类：IDEA风格ctrl+alt+B在按F2查看详细文档注解查看类或接口的继承关系：ctrl+h1、IDEA_查找接口的实现的快捷键 个人分类管理http://blog.csdn.net/u010003835/article/details/790366662、intellijidea8.1.2中找到实现一个类或者接口子类的快捷键 https://zhidao.ba…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年8月15日
    15
  • 有赞和腾讯云、阿里云一同摘得“中国企业云科技服务商50强”[通俗易懂] 科技

    有赞和腾讯云、阿里云一同摘得“中国企业云科技服务商50强”[通俗易懂]

    有赞和腾讯云、阿里云一同摘得“中国企业云科技服务商50强”[通俗易懂]互联网时代的每一次技术变革都带来新的机会，而云计算这一诞生于2006年的新技术正在引领新的科技浪潮。正是从2006年开始，众多云计算公司借助云计算的东风，成长为数十亿、上百亿甚至超千亿美元市值的科技公司。亚马逊就是在2006年转向云计算之后，用十年时间成长为一家万亿美元市值的公司。在亚马逊之后，Salesforce也稳稳站上了千亿美元市值。而ServiceNow、Workday、Veeva、Shopify则在向500亿美元关口冲刺。紧随其后的是大量数十亿美元市值的云计算公司，它们分布在企业服务的…

    全栈程序员-站长的头像 全栈程序员-站长
    2022年6月15日
    51

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

关注全栈程序员社区公众号