Implementation of quick sort (array + linked list), merge sort (array + linked list), heap sort (array)

quick sort

Array implementation

#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;
}

Linked list implementation (exchange pointers)

#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;
}

merge sort

Array version

#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;
}

linked list version

#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;
}

heap sort

Array version

#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;
}