欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

QT中幾種常用的排序函數(shù)用法總結(jié)

 更新時間:2024年01月29日 11:24:17   作者:吻等離子  
Qt是目前最先進、最完整的跨平臺C++開發(fā)工具,下面這篇文章主要給大家介紹了關(guān)于QT中幾種常用的排序函數(shù)用法的相關(guān)資料,文中通過代碼介紹的非常詳細(xì),需要的朋友可以參考下

第一章:排序函數(shù)的概述

排序函數(shù)是一種在編程中常用的函數(shù),它可以對一個序列(如數(shù)組,列表,向量等)中的元素進行排序,使其按照一定的順序排列。排序函數(shù)可以根據(jù)不同的排序算法,如冒泡排序,選擇排序,插入排序,快速排序,歸并排序,堆排序等,實現(xiàn)不同的排序效果。排序函數(shù)的作用有以下幾點:

  • 提高查找效率。當(dāng)一個序列中的元素是有序的,就可以使用一些高效的查找算法,如二分查找,插值查找,斐波那契查找等,來快速地找到目標(biāo)元素。
  • 方便數(shù)據(jù)分析。當(dāng)一個序列中的元素是有序的,就可以方便地進行一些數(shù)據(jù)分析,如求最大值,最小值,中位數(shù),眾數(shù),分位數(shù),頻率分布,直方圖等。
  • 增加數(shù)據(jù)可讀性。當(dāng)一個序列中的元素是有序的,就可以增加數(shù)據(jù)的可讀性,使其更容易被人理解和比較。

QT是一個跨平臺的應(yīng)用程序開發(fā)框架,它提供了一些常用的排序函數(shù),可以對QT中的一些容器類(如QList,QVector,QMap,QSet等)中的元素進行排序。QT中提供的排序函數(shù)有以下幾種:

  • qSort:這是一個通用的排序函數(shù),它使用快速排序算法,可以對任何可隨機訪問的序列進行排序。它可以指定一個比較函數(shù)或者一個比較對象,來自定義排序的規(guī)則。它的排序結(jié)果是不穩(wěn)定的,也就是說,如果序列中有相等的元素,它們的相對位置可能會改變。
  • qStableSort:這是一個穩(wěn)定的排序函數(shù),它使用歸并排序算法,可以對任何可隨機訪問的序列進行排序。它可以指定一個比較函數(shù)或者一個比較對象,來自定義排序的規(guī)則。它的排序結(jié)果是穩(wěn)定的,也就是說,如果序列中有相等的元素,它們的相對位置不會改變。
  • qPartialSort:這是一個部分排序函數(shù),它使用堆排序算法,可以對任何可隨機訪問的序列進行部分排序。它可以指定一個范圍,只對序列中的這個范圍內(nèi)的元素進行排序,而不影響其他元素。它可以指定一個比較函數(shù)或者一個比較對象,來自定義排序的規(guī)則。它的排序結(jié)果是不穩(wěn)定的。
  • qHeapSort:這是一個堆排序函數(shù),它使用堆排序算法,可以對任何可隨機訪問的序列進行排序。它可以指定一個比較函數(shù)或者一個比較對象,來自定義排序的規(guī)則。它的排序結(jié)果是不穩(wěn)定的。它的特點是,它可以在不使用額外空間的情況下,對序列進行原地排序,也就是說,它不需要創(chuàng)建一個新的序列來存儲排序結(jié)果,而是直接在原序列上進行操作。
  • qLowerBound和qUpperBound:這不是排序函數(shù),而是查找函數(shù),它們可以在一個有序的序列中,查找一個給定的元素的下界和上界。下界是指序列中第一個不小于給定元素的位置,上界是指序列中第一個大于給定元素的位置。它們可以指定一個比較函數(shù)或者一個比較對象,來自定義查找的規(guī)則。它們的查找效率是對數(shù)級別的,也就是說,它們使用二分查找算法,每次查找都可以將查找范圍縮小一半。

第二章:qSort函數(shù)

qSort函數(shù)是QT中提供的一個通用的排序函數(shù),它使用快速排序算法,可以對任何可隨機訪問的序列進行排序。快速排序算法的基本思想是,選擇一個基準(zhǔn)元素,將序列分為兩個子序列,一個子序列中的元素都小于或等于基準(zhǔn)元素,另一個子序列中的元素都大于基準(zhǔn)元素,然后對這兩個子序列遞歸地進行快速排序,最后將兩個子序列合并成一個有序的序列??焖倥判蛩惴ǖ钠骄鶗r間復(fù)雜度是O(nlogn),最壞情況下的時間復(fù)雜度是O(n^2),空間復(fù)雜度是O(logn)。

qSort函數(shù)的函數(shù)原型如下

template <typename RandomAccessIterator>
void qSort(RandomAccessIterator begin, RandomAccessIterator end);

template <typename RandomAccessIterator, typename LessThan>
void qSort(RandomAccessIterator begin, RandomAccessIterator end, LessThan lessThan);

qSort函數(shù)的功能參數(shù)

對從begin到end(不包括end)的元素進行排序。

第一個參數(shù)begin是指向序列開始位置的迭代器

第二個參數(shù)end是指向序列結(jié)束位置的迭代器

第三個參數(shù)lessThan是一個比較函數(shù)或者一個比較對象,它可以自定義排序的規(guī)則,它接受兩個元素作為參數(shù),返回一個布爾值,表示第一個元素是否小于第二個元素。如果沒有指定第三個參數(shù),qSort函數(shù)會使用默認(rèn)的比較規(guī)則,即使用元素的<運算符進行比較。

qSort函數(shù)的用法示例

  • 如果要對一個數(shù)組進行排序,可以直接傳入數(shù)組的首地址和尾地址作為參數(shù),例如:
int arr[] = {5, 3, 7, 1, 9, 4, 6, 8, 2};
qSort(arr, arr + 9); // 對arr數(shù)組進行升序排序
  • 如果要對一個QList或者QVector進行排序,可以使用它們的begin()和end()方法來獲取迭代器,例如:
QList<int> list;
list << 5 << 3 << 7 << 1 << 9 << 4 << 6 << 8 << 2;
qSort(list.begin(), list.end()); // 對list進行升序排序
  • 如果要對一個QMap或者QSet進行排序,可以使用它們的keys()或者values()方法來獲取一個QList,然后對QList進行排序,例如:
QMap<QString, int> map;
map["Alice"] = 90;
map["Bob"] = 80;
map["Charlie"] = 85;
map["David"] = 95;
QList<QString> names = map.keys(); // 獲取map的鍵的列表
qSort(names.begin(), names.end()); // 對names進行升序排序
  • 如果要自定義排序的規(guī)則,可以傳入一個比較函數(shù)或者一個比較對象作為第三個參數(shù),例如:
// 定義一個比較函數(shù),按照字符串的長度進行比較
bool compareByLength(const QString &a, const QString &b)
{
    return a.length() < b.length();
}

// 定義一個比較對象,按照學(xué)生的成績進行比較
struct compareByScore
{
    bool operator()(const Student &a, const Student &b)
    {
        return a.score > b.score; // 降序排序
    }
};

QList<QString> words;
words << "apple" << "banana" << "orange" << "pear" << "grape";
qSort(words.begin(), words.end(), compareByLength); // 按照單詞的長度進行升序排序

QList<Student> students;
students << Student("Alice", 90) << Student("Bob", 80) << Student("Charlie", 85) << Student("David", 95);
qSort(students.begin(), students.end(), compareByScore()); // 按照學(xué)生的成績進行降序排序

qSort函數(shù)注意事項

  • begin和end必須指向同一個序列,否則會導(dǎo)致未定義的行為。
  • begin和end之間的元素必須能夠被交換,否則會導(dǎo)致編譯錯誤。
  • begin和end之間的元素必須能夠被比較,否則會導(dǎo)致編譯錯誤或者運行時錯誤。
  • lessThan必須是一個嚴(yán)格弱序關(guān)系,也就是說,它必須滿足以下條件:
    • 對于任何元素x,lessThan(x, x)必須返回false。
    • 如果lessThan(x, y)返回true,那么lessThan(y, x)必須返回false。
    • 如果lessThan(x, y)和lessThan(y, z)都返回true,那么lessThan(x, z)也必須返回true。
  • qSort函數(shù)的排序結(jié)果是不穩(wěn)定的,也就是說,如果序列中有相等的元素(即lessThan(x, y)和lessThan(y, x)都返回false),它們的相對位置可能會改變。

以上就是qSort函數(shù)的介紹,下面我們將介紹qStableSort函數(shù)。

第三章:qStableSort函數(shù)

qStableSort函數(shù)是QT中提供的一個穩(wěn)定的排序函數(shù),它使用歸并排序算法,可以對任何可隨機訪問的序列進行排序。歸并排序算法的基本思想是,將序列分為兩個子序列,對這兩個子序列分別進行歸并排序,然后將兩個有序的子序列合并成一個有序的序列。歸并排序算法的時間復(fù)雜度是O(nlogn),空間復(fù)雜度是O(n)。

qStableSort函數(shù)的函數(shù)原型如下

template <typename RandomAccessIterator>
void qStableSort(RandomAccessIterator begin, RandomAccessIterator end);

template <typename RandomAccessIterator, typename LessThan>
void qStableSort(RandomAccessIterator begin, RandomAccessIterator end, LessThan lessThan);

qStableSort函數(shù)的功能參數(shù)

對從begin到end(不包括end)的元素進行排序

第一個參數(shù)begin是指向序列開始位置的迭代器

第二個參數(shù)end是指向序列結(jié)束位置的迭代器

第三個參數(shù)lessThan是一個比較函數(shù)或者一個比較對象,它可以自定義排序的規(guī)則,它接受兩個元素作為參數(shù),返回一個布爾值,表示第一個元素是否小于第二個元素。如果沒有指定第三個參數(shù),qStableSort函數(shù)會使用默認(rèn)的比較規(guī)則,即使用元素的<運算符進行比較。

qStableSort函數(shù)的用法示例

qStableSort函數(shù)的用法和qSort函數(shù)的用法基本相同,只是qStableSort函數(shù)的排序結(jié)果是穩(wěn)定的,也就是說,如果序列中有相等的元素(即lessThan(x, y)和lessThan(y, x)都返回false),它們的相對位置不會改變。這一點在一些場景中是很重要的,例如,如果要對一個學(xué)生的列表按照姓名進行排序,然后再按照成績進行排序,如果使用qSort函數(shù),那么姓名相同的學(xué)生的成績順序可能會被打亂,而如果使用qStableSort函數(shù),那么姓名相同的學(xué)生的成績順序會保持不變。

代碼示例:

#include <QList>
#include <QString>
#include <QDebug>

// 定義一個學(xué)生類,包含姓名和成績兩個屬性
class Student
{
public:
    Student(const QString &name, int score) : name(name), score(score) {}
    QString name; // 姓名
    int score; // 成績
};

// 定義一個比較函數(shù),按照姓名進行升序排序
bool compareByName(const Student &a, const Student &b)
{
    return a.name < b.name;
}

// 定義一個比較函數(shù),按照成績進行降序排序
bool compareByScore(const Student &a, const Student &b)
{
    return a.score > b.score;
}

// 創(chuàng)建一個學(xué)生的列表
    QList<Student> students;
    students << Student("Alice", 90) << Student("Bob", 80) << Student("Charlie", 85) << Student("David", 95) << Student("Alice", 88) << Student("Bob", 82);

    // 使用qStableSort函數(shù)按照姓名進行排序
    qStableSort(students.begin(), students.end(), compareByName);

    // 打印排序后的結(jié)果
    qDebug() << "Sorted by name:";
    for (const Student &s : students)
    {
        qDebug() << s.name << s.score;
    }

    // 使用qStableSort函數(shù)按照成績進行排序
    qStableSort(students.begin(), students.end(), compareByScore);

    // 打印排序后的結(jié)果
    qDebug() << "Sorted by score:";
    for (const Student &s : students)
    {
        qDebug() << s.name << s.score;
    }

運行這段代碼,可以得到以下輸出:

Sorted by name:
Alice 90
Alice 88
Bob 80
Bob 82
Charlie 85
David 95
Sorted by score:
David 95
Alice 90
Alice 88
Charlie 85
Bob 82
Bob 80

可以看到,qStableSort函數(shù)的排序結(jié)果是穩(wěn)定的,也就是說,姓名相同的學(xué)生的成績順序沒有改變,而是保持了原來的順序。這樣就可以方便地對數(shù)據(jù)進行分組或者分析。

qStableSort函數(shù)注意事項

  • begin和end必須指向同一個序列,否則會導(dǎo)致未定義的行為。
  • begin和end之間的元素必須能夠被交換,否則會導(dǎo)致編譯錯誤。
  • begin和end之間的元素必須能夠被比較,否則會導(dǎo)致編譯錯誤或者運行時錯誤。
  • lessThan必須是一個嚴(yán)格弱序關(guān)系,也就是說,它必須滿足以下條件:
    • 對于任何元素x,lessThan(x, x)必須返回false。
    • 如果lessThan(x, y)返回true,那么lessThan(y, x)必須返回false。
    • 如果lessThan(x, y)和lessThan(y, z)都返回true,那么lessThan(x, z)也必須返回true。
  • qStableSort函數(shù)的排序結(jié)果是穩(wěn)定的,也就是說,如果序列中有相等的元素,它們的相對位置不會改變。

以上就是qStableSort函數(shù)的介紹,下面我們將介紹qPartialSort函數(shù)

第四章:qPartialSort函數(shù)

qPartialSort函數(shù)是QT中提供的一個部分排序函數(shù),它使用堆排序算法,可以對任何可隨機訪問的序列進行部分排序。堆排序算法的基本思想是,將序列視為一個完全二叉樹,然后構(gòu)建一個最大堆或者最小堆,也就是說,每個節(jié)點的值都大于或者小于它的子節(jié)點的值。然后,將堆的根節(jié)點(也就是最大或者最小的元素)與堆的最后一個節(jié)點交換,然后將堆的大小減一,再調(diào)整堆的結(jié)構(gòu),重復(fù)這個過程,直到堆的大小等于指定的范圍。堆排序算法的時間復(fù)雜度是O(nlogn),空間復(fù)雜度是O(1)。

qPartialSort函數(shù)的函數(shù)原型

template <typename RandomAccessIterator>
void qPartialSort(RandomAccessIterator begin, RandomAccessIterator middle, RandomAccessIterator end);

template <typename RandomAccessIterator, typename LessThan>
void qPartialSort(RandomAccessIterator begin, RandomAccessIterator middle, RandomAccessIterator end, LessThan lessThan);

qPartialSort函數(shù)的功能參數(shù)

對從begin到end(不包括end)的元素進行部分排序,使得從begin到middle(不包括middle)的元素是最小的或者最大的,而且是有序的,而從middle到end的元素是無序的。

第一個參數(shù)begin是指向序列開始位置的迭代器

第二個參數(shù)middle是指向序列中間位置的迭代器

第三個參數(shù)end是指向序列結(jié)束位置的迭代器

第四個參數(shù)lessThan是一個比較函數(shù)或者一個比較對象,它可以自定義排序的規(guī)則,它接受兩個元素作為參數(shù),返回一個布爾值,表示第一個元素是否小于第二個元素。如果沒有指定第四個參數(shù),qPartialSort函數(shù)會使用默認(rèn)的比較規(guī)則,即使用元素的<運算符進行比較。

qPartialSort函數(shù)的用法示例

  • 如果要對一個數(shù)組進行部分排序,可以直接傳入數(shù)組的首地址,中間地址和尾地址作為參數(shù),例如:
int arr[] = {5, 3, 7, 1, 9, 4, 6, 8, 2};
qPartialSort(arr, arr + 3, arr + 9); // 對arr數(shù)組進行部分排序,使得前三個元素是最小的,并且是有序的
  • 如果要對一個QList或者QVector進行部分排序,可以使用它們的begin()和end()方法來獲取迭代器,例如:
QList<int> list;
list << 5 << 3 << 7 << 1 << 9 << 4 << 6 << 8 << 2;
qPartialSort(list.begin(), list.begin() + 3, list.end()); // 對list進行部分排序,使得前三個元素是最小的,并且是有序的
  • 如果要對一個QMap或者QSet進行部分排序,可以使用它們的keys()或者values()方法來獲取一個QList,然后對QList進行部分排序,例如:
QMap<QString, int> map;
map["Alice"] = 90;
map["Bob"] = 80;
map["Charlie"] = 85;
map["David"] = 95;
QList<int> scores = map.values(); // 獲取map的值的列表
qPartialSort(scores.begin(), scores.begin() + 2, scores.end()); // 對scores進行部分排序,使得前兩個元素是最小的,并且是有序的
  • 如果要自定義排序的規(guī)則,可以傳入一個比較函數(shù)或者一個比較對象作為第四個參數(shù),例如:
// 定義一個比較函數(shù),按照字符串的長度進行比較
bool compareByLength(const QString &a, const QString &b)
{
    return a.length() < b.length();
}

// 定義一個比較對象,按照學(xué)生的成績進行比較
struct compareByScore
{
    bool operator()(const Student &a, const Student &b)
    {
        return a.score > b.score; // 降序排序
    }
};

QList<QString> words;
words << "apple" << "banana" << "orange" << "pear" << "grape";
qPartialSort(words.begin(), words.begin() + 2, words.end(), compareByLength); // 按照單詞的長度進行部分排序,使得前兩個元素是最短的,并且是有序的

QList<Student> students;
students << Student("Alice", 90) << Student("Bob", 80) << Student("Charlie", 85) << Student("David", 95);
qPartialSort(students.begin(), students.begin() + 2, students.end(), compareByScore()); // 按照學(xué)生的成績進行部分排序,使得前兩個元素是最高的,并且是有序的

qPartialSort函數(shù)注意事項

  • begin,middle和end必須指向同一個序列,否則會導(dǎo)致未定義的行為。
  • begin,middle和end之間的元素必須能夠被交換,否則會導(dǎo)致編譯錯誤。
  • begin,middle和end之間的元素必須能夠被比較,否則會導(dǎo)致編譯錯誤或者運行時錯誤。
  • lessThan必須是一個嚴(yán)格弱序關(guān)系,也就是說,它必須滿足以下條件:
    • 對于任何元素x,lessThan(x, x)必須返回false。
    • 如果lessThan(x, y)返回true,那么lessThan(y, x)必須返回false。
    • 如果lessThan(x, y)和lessThan(y, z)都返回true,那么lessThan(x, z)也必須返回true。
  • qPartialSort函數(shù)的排序結(jié)果是不穩(wěn)定的,也就是說,如果序列中有相等的元素,它們的相對位置可能會改變。

以上就是qPartialSort函數(shù)的介紹,下面我們將介紹qHeapSort函數(shù)。

第五章:qHeapSort函數(shù)

qHeapSort函數(shù)是QT中提供的一個堆排序函數(shù),它使用堆排序算法,可以對任何可隨機訪問的序列進行排序。堆排序算法的基本思想是,將序列視為一個完全二叉樹,然后構(gòu)建一個最大堆或者最小堆,也就是說,每個節(jié)點的值都大于或者小于它的子節(jié)點的值。然后,將堆的根節(jié)點(也就是最大或者最小的元素)與堆的最后一個節(jié)點交換,然后將堆的大小減一,再調(diào)整堆的結(jié)構(gòu),重復(fù)這個過程,直到堆的大小為零。堆排序算法的時間復(fù)雜度是O(nlogn),空間復(fù)雜度是O(1)。

qHeapSort函數(shù)的函數(shù)原型

template <typename RandomAccessIterator>
void qHeapSort(RandomAccessIterator begin, RandomAccessIterator end);

template <typename RandomAccessIterator, typename LessThan>
void qHeapSort(RandomAccessIterator begin, RandomAccessIterator end, LessThan lessThan);

qHeapSort函數(shù)的功能是參數(shù)

對從begin到end(不包括end)的元素進行排序。

第一個參數(shù)begin是指向序列開始位置的迭代器

第二個參數(shù)end是指向序列結(jié)束位置的迭代器

第三個參數(shù)lessThan是一個比較函數(shù)或者一個比較對象,它可以自定義排序的規(guī)則,它接受兩個元素作為參數(shù),返回一個布爾值,表示第一個元素是否小于第二個元素。如果沒有指定第三個參數(shù),qHeapSort函數(shù)會使用默認(rèn)的比較規(guī)則,即使用元素的<運算符進行比較。

qHeapSort函數(shù)的用法示例

qSort函數(shù)的用法基本相同,只是qHeapSort函數(shù)的特點是,它可以在不使用額外空間的情況下,對序列進行原地排序,也就是說,它不需要創(chuàng)建一個新的序列來存儲排序結(jié)果,而是直接在原序列上進行操作。這樣就可以節(jié)省空間,提高效率。

代碼示例:

#include <QList>
#include <QString>
#include <QDebug>

// 定義一個學(xué)生類,包含姓名和成績兩個屬性
class Student
{
public:
    Student(const QString &name, int score) : name(name), score(score) {}
    QString name; // 姓名
    int score; // 成績
};

// 定義一個比較函數(shù),按照姓名進行升序排序
bool compareByName(const Student &a, const Student &b)
{
    return a.name < b.name;
}

// 定義一個比較函數(shù),按照成績進行降序排序
bool compareByScore(const Student &a, const Student &b)
{
    return a.score > b.score;
}
    // 創(chuàng)建一個學(xué)生的列表
    QList<Student> students;
    students << Student("Alice", 90) << Student("Bob", 80) << Student("Charlie", 85) << Student("David", 95);

    // 使用qHeapSort函數(shù)按照姓名進行排序
    qHeapSort(students.begin(), students.end(), compareByName);

    // 打印排序后的結(jié)果
    qDebug() << "Sorted by name:";
    for (const Student &s : students)
    {
        qDebug() << s.name << s.score;
    }

    // 使用qHeapSort函數(shù)按照成績進行排序
    qHeapSort(students.begin(), students.end(), compareByScore);

    // 打印排序后的結(jié)果
    qDebug() << "Sorted by score:";
    for (const Student &s : students)
    {
        qDebug() << s.name << s.score;
    }

 運行這段代碼,可以得到以下輸出:

Sorted by name:
Alice 90
Bob 80
Charlie 85
David 95
Sorted by score:
David 95
Alice 90
Charlie 85
Bob 80

可以看到,qHeapSort函數(shù)的排序結(jié)果是不穩(wěn)定的,也就是說,姓名相同的學(xué)生的成績順序可能會改變,而且它可以在不使用額外空間的情況下,對序列進行原地排序,也就是說,它不需要創(chuàng)建一個新的序列來存儲排序結(jié)果,而是直接在原序列上進行操作。

qHeapSort函數(shù)的注意事項

  • begin和end必須指向同一個序列,否則會導(dǎo)致未定義的行為。
  • begin和end之間的元素必須能夠被交換,否則會導(dǎo)致編譯錯誤。
  • begin和end之間的元素必須能夠被比較,否則會導(dǎo)致編譯錯誤或者運行時錯誤。
  • lessThan必須是一個嚴(yán)格弱序關(guān)系,也就是說,它必須滿足以下條件:
    • 對于任何元素x,lessThan(x, x)必須返回false。
    • 如果lessThan(x, y)返回true,那么lessThan(y, x)必須返回false。
    • 如果lessThan(x, y)和lessThan(y, z)都返回true,那么lessThan(x, z)也必須返回true。
  • qHeapSort函數(shù)的排序結(jié)果是不穩(wěn)定的,也就是說,如果序列中有相等的元素,它們的相對位置可能會改變。

以上就是qHeapSort函數(shù)的介紹,下面我們將介紹qLowerBound和qUpperBound函數(shù)。

第六章:qLowerBound和qUpperBound函數(shù)

qLowerBound和qUpperBound函數(shù)是QT中提供的兩個查找函數(shù),它們可以在一個有序的序列中,查找一個給定的元素的下界和上界。下界是指序列中第一個不小于給定元素的位置,上界是指序列中第一個大于給定元素的位置。它們可以指定一個比較函數(shù)或者一個比較對象,來自定義查找的規(guī)則。它們的查找效率是對數(shù)級別的,也就是說,它們使用二分查找算法,每次查找都可以將查找范圍縮小一半。

qLowerBound和qUpperBound函數(shù)的函數(shù)原型

template <typename ForwardIterator, typename T>
ForwardIterator qLowerBound(ForwardIterator begin, ForwardIterator end, const T &value);

template <typename ForwardIterator, typename T, typename LessThan>
ForwardIterator qLowerBound(ForwardIterator begin, ForwardIterator end, const T &value, LessThan lessThan);

template <typename ForwardIterator, typename T>
ForwardIterator qUpperBound(ForwardIterator begin, ForwardIterator end, const T &value);

template <typename ForwardIterator, typename T, typename LessThan>
ForwardIterator qUpperBound(ForwardIterator begin, ForwardIterator end, const T &value, LessThan lessThan);

qLowerBound和qUpperBound函數(shù)的功能和參數(shù)

分別在從begin到end(不包括end)的元素中,查找value的下界和上界。

第一個參數(shù)begin是指向序列開始位置的迭代器

第二個參數(shù)end是指向序列結(jié)束位置的迭代器

第三個參數(shù)value是要查找的元素

第四個參數(shù)lessThan是一個比較函數(shù)或者一個比較對象,它可以自定義查找的規(guī)則,它接受兩個元素作為參數(shù),返回一個布爾值,表示第一個元素是否小于第二個元素。如果沒有指定第四個參數(shù),qLowerBound和qUpperBound函數(shù)會使用默認(rèn)的比較規(guī)則,即使用元素的<運算符進行比較。

qLowerBound和qUpperBound函數(shù)的用法示例

  • 如果要在一個數(shù)組中查找一個元素的下界和上界,可以直接傳入數(shù)組的首地址和尾地址作為參數(shù),例如:
int arr[] = {1, 2, 3, 3, 3, 4, 5};
int *lower = qLowerBound(arr, arr + 7, 3); // 查找3的下界
int *upper = qUpperBound(arr, arr + 7, 3); // 查找3的上界
qDebug() << "Lower bound of 3 is" << lower - arr; // 輸出3的下界的索引
qDebug() << "Upper bound of 3 is" << upper - arr; // 輸出3的上界的索引
  • 如果要在一個QList或者QVector中查找一個元素的下界和上界,可以使用它們的begin()和end()方法來獲取迭代器,例如:
QList<int> list;
list << 1 << 2 << 3 << 3 << 3 << 4 << 5;
QList<int>::iterator lower = qLowerBound(list.begin(), list.end(), 3); // 查找3的下界
QList<int>::iterator upper = qUpperBound(list.begin(), list.end(), 3); // 查找3的上界
qDebug() << "Lower bound of 3 is" << lower - list.begin(); // 輸出3的下界的索引
qDebug() << "Upper bound of 3 is" << upper - list.begin(); // 輸出3的上界的索引
  • 如果要在一個QMap或者QSet中查找一個元素的下界和上界,可以使用它們的keys()或者values()方法來獲取一個QList,然后在QList中查找,例如:
QMap<QString, int> map;
map["Alice"] = 90;
map["Bob"] = 80;
map["Charlie"] = 85;
map["David"] = 95;
QList<int> scores = map.values(); // 獲取map的值的列表
qSort(scores.begin(), scores.end()); // 對scores進行排序
QList<int>::iterator lower = qLowerBound(scores.begin(), scores.end(), 85); // 查找85的下界
QList<int>::iterator upper = qUpperBound(scores.begin(), scores.end(), 85); // 查找85的上界
qDebug() << "Lower bound of 85 is" << lower - scores.begin(); // 輸出85的下界的索引
qDebug() << "Upper bound of 85 is" << upper - scores.begin(); // 輸出85的上界的索引

第七章:總結(jié)

本文介紹了QT中的幾種常用的排序函數(shù),包括qSort,qStableSort,qPartialSort,qHeapSort,qLowerBound和qUpperBound,它們可以對QT中的一些容器類中的元素進行排序或者查找。

下面我們將比較一下不同排序函數(shù)的優(yōu)缺點,以及給出一些使用建議:

  • qSort函數(shù)是一個通用的排序函數(shù),它使用快速排序算法,可以對任何可隨機訪問的序列進行排序。它的優(yōu)點是,它的平均時間復(fù)雜度是O(nlogn),空間復(fù)雜度是O(logn),效率較高。它的缺點是,它的最壞情況下的時間復(fù)雜度是O(n^2),效率較低。另外,它的排序結(jié)果是不穩(wěn)定的,也就是說,如果序列中有相等的元素,它們的相對位置可能會改變。因此,如果要對一個序列進行排序,可以使用qSort函數(shù),但是要注意避免最壞情況的發(fā)生,以及考慮是否需要保持元素的相對位置。
  • qStableSort函數(shù)是一個穩(wěn)定的排序函數(shù),它使用歸并排序算法,可以對任何可隨機訪問的序列進行排序。它的優(yōu)點是,它的時間復(fù)雜度是O(nlogn),效率較高。另外,它的排序結(jié)果是穩(wěn)定的,也就是說,如果序列中有相等的元素,它們的相對位置不會改變。這一點在一些場景中是很重要的,例如,如果要對一個學(xué)生的列表按照姓名進行排序,然后再按照成績進行排序,如果使用qSort函數(shù),那么姓名相同的學(xué)生的成績順序可能會被打亂,而如果使用qStableSort函數(shù),那么姓名相同的學(xué)生的成績順序會保持不變。它的缺點是,它的空間復(fù)雜度是O(n),需要額外的空間來存儲排序結(jié)果。因此,如果要對一個序列進行排序,而且需要保持元素的相對位置,可以使用qStableSort函數(shù),但是要注意空間的消耗。
  • qPartialSort函數(shù)是一個部分排序函數(shù),它使用堆排序算法,可以對任何可隨機訪問的序列進行部分排序。它的優(yōu)點是,它可以指定一個范圍,只對序列中的這個范圍內(nèi)的元素進行排序,而不影響其他元素。這樣就可以節(jié)省時間,提高效率。它的缺點是,它的排序結(jié)果是不穩(wěn)定的,也就是說,如果序列中有相等的元素,它們的相對位置可能會改變。另外,它的時間復(fù)雜度是O(nlogn),空間復(fù)雜度是O(1),效率和空間都不是最優(yōu)的。因此,如果要對一個序列進行部分排序,可以使用qPartialSort函數(shù),但是要注意元素的相對位置,以及是否有更好的算法。
  • qHeapSort函數(shù)是一個堆排序函數(shù),它使用堆排序算法,可以對任何可隨機訪問的序列進行排序。它的優(yōu)點是,它可以在不使用額外空間的情況下,對序列進行原地排序,也就是說,它不需要創(chuàng)建一個新的序列來存儲排序結(jié)果,而是直接在原序列上進行操作。這樣就可以節(jié)省空間,提高效率。它的缺點是,它的排序結(jié)果是不穩(wěn)定的,也就是說,如果序列中有相等的元素,它們的相對位置可能會改變。另外,它的時間復(fù)雜度是O(nlogn),空間復(fù)雜度是O(1),效率和空間都不是最優(yōu)的。因此,如果要對一個序列進行排序,而且不需要保持元素的相對位置,也不需要額外的空間,可以使用qHeapSort函數(shù),但是要注意是否有更好的算法。
  • qLowerBound和qUpperBound函數(shù)是兩個查找函數(shù),它們可以在一個有序的序列中,查找一個給定的元素的下界和上界。它們的優(yōu)點是,它們的查找效率是對數(shù)級別的,也就是說,它們使用二分查找算法,每次查找都可以將查找范圍縮小一半。這樣就可以快速地找到目標(biāo)元素。它們的缺點是,它們的查找結(jié)果是一個迭代器,它可以用來訪問或者修改序列中的元素,也可以用來計算元素的位置或者個數(shù),但是它不能直接用來判斷元素是否存在于序列中,也不能直接用來獲取元素的值。因此,如果要在一個有序的序列中,查找一個給定的元素的下界和上界,可以使用qLowerBound和qUpperBound函數(shù),但是要注意如何使用查找結(jié)果。

到此這篇關(guān)于QT中幾種常用的排序函數(shù)用法總結(jié)的文章就介紹到這了,更多相關(guān)QT排序函數(shù)內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家!

相關(guān)文章

  • C語言實現(xiàn)簡單掃雷小游戲

    C語言實現(xiàn)簡單掃雷小游戲

    這篇文章主要為大家詳細(xì)介紹了C語言實現(xiàn)簡單掃雷小游戲,文中示例代碼介紹的非常詳細(xì),具有一定的參考價值,感興趣的小伙伴們可以參考一下
    2019-10-10
  • C++中拷貝構(gòu)造函數(shù)的總結(jié)詳解

    C++中拷貝構(gòu)造函數(shù)的總結(jié)詳解

    深拷貝和淺拷貝可以簡單理解為:如果一個類擁有資源,當(dāng)這個類的對象發(fā)生復(fù)制過程的時候,資源重新分配,這個過程就是深拷貝,反之,沒有重新分配資源,就是淺拷貝
    2013-09-09
  • C語言中_string.h庫函數(shù)功能及其用法詳解

    C語言中_string.h庫函數(shù)功能及其用法詳解

    在計算機編程中,字符串處理是一項常見而重要的任務(wù),C語言的string.h頭文件提供了一系列函數(shù)和工具,用于對字符串進行操作和處理,本文將對string.h頭文件中的所有函數(shù)進行全面介紹,包括它們的功能和使用方法,以幫助大家更好地理解和利用該頭文件
    2023-12-12
  • 深入講解Socket原理

    深入講解Socket原理

    這篇文章深入的講解Socket原理,并附帶實例代碼。小編覺得挺不錯的,現(xiàn)在分享給大家,也給大家做個參考。一起跟隨小編過來看看吧
    2021-12-12
  • C語言超詳細(xì)講解函數(shù)棧幀的創(chuàng)建和銷毀

    C語言超詳細(xì)講解函數(shù)棧幀的創(chuàng)建和銷毀

    我們知道c語言中函數(shù)都是被調(diào)用的,main函數(shù)里面能調(diào)用其他函數(shù),其實main函數(shù)也是被別的函數(shù)調(diào)用的,下面通過本文給大家分享c語言函數(shù)棧幀的創(chuàng)建和銷毀過程,一起看看吧
    2022-05-05
  • 一篇文章帶你了解C++Primer學(xué)習(xí)日記--處理數(shù)據(jù)

    一篇文章帶你了解C++Primer學(xué)習(xí)日記--處理數(shù)據(jù)

    今天小編就為大家分享一篇關(guān)于C++對數(shù)器的使用講解,小編覺得內(nèi)容挺不錯的,現(xiàn)在分享給大家,具有很好的參考價值,需要的朋友一起跟隨小編來看看吧
    2021-08-08
  • C++特殊成員函數(shù)以及其生成機制詳解

    C++特殊成員函數(shù)以及其生成機制詳解

    這篇文章主要給大家介紹了關(guān)于C++特殊成員函數(shù)以及其生成機制的相關(guān)資料,文中通過實例代碼介紹的非常詳細(xì),對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下
    2022-02-02
  • C++實現(xiàn)獲取本機MAC地址與IP地址

    C++實現(xiàn)獲取本機MAC地址與IP地址

    這篇文章主要為大家詳細(xì)介紹了C++實現(xiàn)獲取本機MAC地址與IP地址的兩種方式,文中的示例代碼講解詳細(xì),感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下
    2025-02-02
  • C++獲取文件大小數(shù)值的三種方式介紹

    C++獲取文件大小數(shù)值的三種方式介紹

    最近在做項目時經(jīng)常需要獲得文件的大小操作,雖然在網(wǎng)絡(luò)上已經(jīng)有許多篇博客介紹了,但是還是想總結(jié)出自己一篇,記錄一下自己在項目中是怎么獲得文件大小的
    2022-10-10
  • MFC繪制不規(guī)則窗體的方法

    MFC繪制不規(guī)則窗體的方法

    這篇文章主要介紹了MFC繪制不規(guī)則窗體的方法,涉及MFC窗體操作的相關(guān)技巧,需要的朋友可以參考下
    2015-05-05

最新評論