用c加加写一个快速排序

用 C++ 写一个快速排序的示例代码如下： void qsort(int s[], int l, int r)
{
if (l < r)
{
int i = l, j = r;
int x = s[l];
while (i < j)
{
while(i < j && s[j] >= x)
j--;
if(i < j)
s[i++] = s[j];
while(i < j && s[i] < x)
i++;
if(i < j)
s[j--] = s[i];
}
s[i] = x;
qsort(s, l, i - 1);
qsort(s, i + 1, r);
}
}

相关问题

分治法快速排序c加加代码

分治法是一种常见的算法策略，它将大问题分解成较小的、相似的子问题，并递归地解决它们，最后合并结果。快速排序是一种基于分治思想的高效排序算法，它的基本步骤包括选择基准元素、分区操作以及递归地对左右两部分进行排序。

以下是使用 C++ 实现的简单版本的快速排序代码：

#include <iostream>
using namespace std;

void swap(int* a, int* b) {
    int t = *a;
    *a = *b;
    *b = t;
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high]; // 通常选择最后一个元素作为基准
    int i = (low - 1); // Index of smaller element

    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++; // increment index of smaller element
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]); // Move pivot to its correct position
    return (i + 1);
}

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);

        quickSort(arr, low, pi - 1); // Before pi
        quickSort(arr, pi + 1, high); // After pi
    }
}

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    quickSort(arr, 0, n - 1);
    cout << "Sorted array: \n";
    for (int i=0; i < n; i++)
        cout << arr[i] << " ";
    return 0;
}

在这个例子中，`quickSort()` 函数负责递归调用，而 `partition()` 函数则完成了分区和基准元素交换的过程。运行这个程序会得到一个已排序的数组。

用c加加写出乐库个人管理系统，要求涉及增，删，改和散列查找和以年份排序

好的，下面是一个简单的乐库个人管理系统的实现，包括增加音乐、删除音乐、修改音乐信息、散列查找和以年份排序的功能。这里使用了哈希表来实现散列查找，使用快速排序来实现年份排序。

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

// 歌曲类
class Song {
public:
    int id;             // 歌曲编号
    string name;        // 歌曲名称
    string artist;      // 歌手名称
    string album;       // 专辑名称
    int year;           // 发行年份

    Song() {}
    Song(int _id, string _name, string _artist, string _album, int _year) :
        id(_id), name(_name), artist(_artist), album(_album), year(_year) {}
};

// 哈希表类
class HashTable {
private:
    static const int MAXN = 10003;   // 哈希表最大容量
    vector<Song> table[MAXN];       // 哈希表数组
    int hash(string s) {            // 哈希函数，将字符串映射为整数
        int ans = 0;
        for (int i = 0; i < s.length(); i++) {
            ans = ans * 131 + s[i];
        }
        return ans;
    }
public:
    void insert(Song s) {           // 插入操作，将歌曲加入哈希表
        int index = (hash(s.name) + hash(s.artist) + hash(s.album)) % MAXN;
        table[index].push_back(s);
    }
    void remove(Song s) {           // 删除操作，将歌曲从哈希表中移除
        int index = (hash(s.name) + hash(s.artist) + hash(s.album)) % MAXN;
        for (int i = 0; i < table[index].size(); i++) {
            if (table[index][i].id == s.id) {
                table[index].erase(table[index].begin() + i);
                break;
            }
        }
    }
    vector<Song> find(string name) {    // 查找操作，根据歌曲名返回所有匹配的歌曲
        int index = hash(name) % MAXN;
        vector<Song> ans;
        for (int i = 0; i < table[index].size(); i++) {
            if (table[index][i].name == name) {
                ans.push_back(table[index][i]);
            }
        }
        return ans;
    }
};

// 年份排序类
class YearSorter {
public:
    bool operator()(const Song& s1, const Song& s2) {
        return s1.year < s2.year;
    }
};

int main() {
    HashTable hashTable;    // 创建哈希表
    vector<Song> songs;     // 创建歌曲数组
    int id = 0;             // 当前歌曲编号

    // 添加歌曲
    songs.push_back(Song(++id, "Lemon", "米津玄师", "Lemon", 2018));
    songs.push_back(Song(++id, "打上花火", "DAOKO×米津玄师", "打上花火", 2017));
    songs.push_back(Song(++id, "愛をこめて花束を", "Superfly", "愛をこめて花束を", 2008));
    songs.push_back(Song(++id, "I Love You", "尾崎豊", "I Love You", 1991));
    songs.push_back(Song(++id, "Lovers", "7!!", "Lovers", 2015));

    // 将歌曲加入哈希表
    for (int i = 0; i < songs.size(); i++) {
        hashTable.insert(songs[i]);
    }

    // 删除歌曲
    hashTable.remove(songs[0]);

    // 修改歌曲信息
    songs[1].year = 2018;
    hashTable.remove(songs[1]);
    hashTable.insert(songs[1]);

    // 查找歌曲
    vector<Song> results = hashTable.find("Lovers");
    for (int i = 0; i < results.size(); i++) {
        cout << results[i].name << " - " << results[i].artist << endl;
    }

    // 年份排序
    sort(songs.begin(), songs.end(), YearSorter());
    for (int i = 0; i < songs.size(); i++) {
        cout << songs[i].name << " - " << songs[i].artist << " (" << songs[i].year << ")" << endl;
    }

    return 0;
}

以上是一个简单的乐库个人管理系统的实现，其中使用了哈希表来实现散列查找和快速删除，使用快速排序来实现年份排序。这只是一个简单的示例，如果你需要更加复杂的功能和需求，你需要根据具体情况来进行实现。