快速排序
数组实现
#include<iostream>
#include<vector>
//第一个数当中轴
void quickSort(int start, int end, std::vector<int> &arr) {
if(start >= end) return ;
int i = start, j = end;
int base = arr[start];
while(i < j) {
while(i < j && arr[j] >= base) j--;
arr[i] = arr[j];
while(i < j && arr[i] <= base) i++;
arr[j] = arr[i];
}
arr[i] = base;
quickSort(start, i-1, arr);
quickSort(i+1, end, arr);
}
//最后一个数当中轴
void quickSort2(int start, int end, std::vector<int> &arr) {
if(start >= end) return ;
int i = start, j = end;
int base = arr[end];
while(i < j) {
while(i < j && arr[i] < base) i++;
arr[j] = arr[i];
while(i < j && arr[j] >= base) j--;
arr[i] = arr[j];
}
arr[j] = base;
quickSort2(start, j-1, arr);
quickSort2(j+1, end, arr);
}
//随机选一个数当中轴
void quickSort3(int start,int end, std::vector<int> &arr) {
if(start >= end) return ;
int randomIndex = start + rand()%(end-start+1);
std::swap(arr[start], arr[randomIndex]);
int base = arr[start];
int i = start, j = end;
while(i < j) {
while(i < j && arr[j] >= base) j--;
arr[i] = arr[j];
while(i < j && arr[i] <= base) i++;
arr[j] = arr[i];
}
arr[i] = base;
quickSort3(start, i-1, arr);
quickSort3(i+1, end, arr);
}
//三者(第一个,第二个,中间)取中值作为中轴
void quickSort4(int start, int end, std::vector<int> &arr) {
if(start >= end) return ;
int mid = start + end >> 1;
if(arr[start] < arr[mid]) std::swap(arr[start], arr[mid]);
if(arr[end] < arr[start]) std::swap(arr[end], arr[start]);
int base = arr[start];
int i = start, j = end;
while(i < j) {
while(i < j && arr[j] >= base) j--;
arr[i] = arr[j];
while(i < j && arr[i] <= base) i++;
arr[j] = arr[i];
}
arr[i] = base;
quickSort4(start, i-1, arr);
quickSort4(i+1, end, arr);
}
int main() {
int n, x;
std::vector<int> arr;
std::cin >> n;
for(int i = 0; i < n; i++) {
std::cin >> x;
arr.emplace_back(x);
}
quickSort4(0, n-1, arr);
for(int i = 0; i < n; i++) {
std::cout << arr[i] << " ";
}
std::cout << std::endl;
return 0;
}
链表实现(交换指针)
#include<iostream>
struct LinkNode {
int val;
LinkNode *next;
LinkNode(int v):val(v), next(nullptr) {}
};
void quickSort(LinkNode* l, LinkNode* r) {
if(l->next == r) return ;
LinkNode *i = l, *base = l->next, *temp;
while(i->next != r) {
if(i->next->val < base->val) {
temp = i->next;
i->next = temp->next;
temp->next = l->next;
l->next = temp;
}
else {
i = i->next;
}
}
quickSort(l, base);
quickSort(base, r);
}
void deleteLink(LinkNode* p) {
if(p == nullptr) return ;
deleteLink(p->next);
delete p;
}
int main() {
int n, x;
std::cin >> n;
LinkNode* head = new LinkNode(0);
LinkNode* p = head;
for(int i = 0; i < n; i++) {
std::cin >> x;
p->next = new LinkNode(x);
p = p->next;
}
quickSort(head,nullptr);
p = head;
while(p->next!=nullptr) {
std::cout << p->next->val << " ";
p = p->next;
}
std::cout << std::endl;
deleteLink(head);
return 0;
}
归并排序
数组版
#include<iostream>
#include<vector>
void merge(std::vector<int> &arr, std::vector<int> &temp, int left, int mid, int right) {
int i = left, j = mid + 1, k = 0;
while(i <= mid && j <= right) {
temp[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
}
while(i <= mid) {
temp[k++] = arr[i++];
}
while(j <= right) {
temp[k++] = arr[j++];
}
for(i = left, k = 0; i <= right; i++, k++) {
arr[i] = temp[k];
}
}
void MergeSort(std::vector<int> &arr, std::vector<int> &temp, int L, int R) {
if(L >= R) return ;
int Mid = L + R >> 1;
MergeSort(arr, temp, L, Mid);
MergeSort(arr, temp, Mid+1, R);
merge(arr, temp, L, Mid, R);
}
int main() {
int n, x;
std::vector<int> arr;
std::cin >> n;
for(int i = 0; i < n; i++) {
std::cin >> x;
arr.emplace_back(x);
}
std::vector<int> temp(n,0);
MergeSort(arr, temp, 0, n-1);
for(int i = 0; i < n; i++) {
std::cout << arr[i] << " ";
}
std::cout << std::endl;
return 0;
}
链表版
#include<iostream>
struct LinkNode {
int val;
LinkNode *next;
LinkNode(int v):val(v), next(nullptr) {}
};
LinkNode* split(LinkNode* head) {
LinkNode* slow = head;
LinkNode* fast = head;
while(fast->next!=nullptr && fast->next->next!=nullptr) {
slow = slow->next;
fast = fast->next->next;
}
LinkNode* temp = slow->next;
slow->next = nullptr;
return temp;
}
LinkNode* merge(LinkNode* head, LinkNode* head2) {
LinkNode* temp = new LinkNode(0);
LinkNode* list = temp;
while(head != nullptr && head2 != nullptr) {
if(head->val <= head2->val) {
list->next = head;
head = head->next;
}
else {
list->next = head2;
head2 = head2->next;
}
list = list->next;
}
if(head != nullptr) list->next = head;
if(head2 != nullptr) list->next = head2;
list = temp->next;
delete temp;
return list;
}
LinkNode* mergeSort(LinkNode* head) {
if(head == nullptr || head->next == nullptr) return head;
LinkNode* head1 = head;
LinkNode* head2 = split(head);
head1 = mergeSort(head1);
head2 = mergeSort(head2);
return merge(head1,head2);
}
void deleteLink(LinkNode* p) {
if(p == nullptr) return ;
deleteLink(p->next);
delete p;
}
int main() {
int n, x;
std::cin >> n;
LinkNode* head = nullptr;
LinkNode* p = head;
for(int i = 0; i < n; i++) {
std::cin >> x;
if(head == nullptr) {
head = new LinkNode(x);
p = head;
}
else {
p->next = new LinkNode(x);
p = p->next;
}
}
p = mergeSort(head);
while(p != nullptr) {
std::cout << p->val << " ";
p = p->next;
}
std::cout << std::endl;
deleteLink(head);
return 0;
}
堆排序
数组版
#include<iostream>
#include<vector>
void adjust(std::vector<int> &arr, int len,int index) {
int l = index*2 + 1;
int r = index*2 + 2;
int maxIndex = index;
if(l < len && arr[l] > arr[maxIndex]) maxIndex=l;
if(r < len && arr[r] > arr[maxIndex]) maxIndex=r;
if(maxIndex != index) {
std::swap(arr[index], arr[maxIndex]);
adjust(arr, len, maxIndex);
}
}
void heapSort(std::vector<int> &arr, int n) {
for(int i = n/2 - 1; i >= 0; i--) {
adjust(arr, n, i);
}
for(int i = n-1; i >= 0; i--) {
std::swap(arr[i], arr[0]);
adjust(arr, i, 0);
}
}
int main() {
int n, x;
std::vector<int> arr;
std::cin >> n;
for(int i = 0; i < n; i++) {
std::cin >> x;
arr.emplace_back(x);
}
heapSort(arr, n);
for(int i = 0; i < n; i++) {
std::cout << arr[i] << " ";
}
std::cout << std::endl;
return 0;
}