2021-7-6各种排序算法（持续）c++实现

插入排序

#include<vector>

void insertsort(vector<int>& arr){
	for(int i = 1;i<arr.size();i++){
		int j = i-1;
		int tmp = arr[i];
		while(j>=0&&arr[j]>tmp){
			arr[j+1]=arr[j];
			j--
		}
		arr[j+1] = tmp;
	}
}

冒泡排序

#include<vector>

void swap(int& a,int& b){
	a = a^b;
	b = a^b;
	a = a^b;
}
void bubbleSort(vector<int>& arr){
	for(int i = arr.size();i>0;i--){
		for(int j = 0;j<i-1;j++){
			if(arr[j]>arr[j+1]){
				swap(arr[j+1],arr[j]);
			}
		}
	}
}

选择排序

#include<vector>

void swap(int& a,int& b){
	a = a^b;
	b = a^b;
	a = a^b;
}
void selectsort(vector<int>& arr) {
    for (int i = arr.size(); i > 0; i--) {
        int maxIndex = 0;
        for (int j = 0; j < i; j++) {
            if (arr[j] > arr[maxIndex]) {
                maxIndex = j;
            }
        }
        swap(arr[maxIndex], arr[i - 1]);
    }
}

希尔排序

#include<vector>
//start是每一组的初始下标，gap是间距
void shellinsertsort(vector<int>& arr, int start, int gap){
	for(int i = start+gap;i<arr.size();i+=gap){
	//j代表无序表的第一个数的下标
		int j = i-gap;
		int tmp = arr[i];
		while(j>=start&&arr[j]>tmp){
			arr[j+1] = arr[j];
			j-=gap;
		}
		arr[j+gap] = tmp;
	}
}
void shellsort(vector<int>& arr){
	for(int gap = arr.size()/2;gap>=1;gap/=2){
		for(int i = 0;i<gap;i++){
			shellinsertsort(arr,i,gap);
		}	
	}
}

桶排序（计数排序）

这里有问题，真正的桶排序不是这样的，这样写并不好，应该结合哈希链表等操作。。。以后再说吧。

#include<vector>

void bucketSort (vector<int>& arr) {
    //找最大值
    int max = INT_MIN;
    for (int i = 0; i < arr.size(); i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    ///创建max+1个桶，给里面的数据置0
    int* bucket = new int[max+1]{ 0 };
    //遍历原数组，对数据进行统计，统计到桶里面，
    for (int i = 0; i < arr.size(); i++) {
        bucket[arr[i]]++;
    }
    //从数组里取出数据，放到原数组里
    arr.clear();
    for (int i = 0; i <= max;) {
        if (bucket[i]) {
            bucket[i]--;
            arr.push_back(i);
        }
        else {
            i++;
        }
            
    }
    delete[] bucket;
}

堆排序（最大堆）

#include<vector>
#include<iostream>
using namespace std;
void swap(int& a, int& b) {
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;
    return;
}
void adjustHeap(vector<int>& arr, int start, int end) {
    int father = start;
    int child = 2 * father + 1;
    while (child<end) {
        if (child + 1 < end&& arr[child] < arr[child + 1]) {
            child++;
        }
        if (arr[child] > arr[father]) {
            swap(arr[child], arr[father]);
        }
        else {
            return;
        }
        father = child;
        child = father * 2 + 1;
    }
}


void heapSort(vector<int>& arr) {
    for (int i = arr.size() / 2 - 1; i > 0; i--) {
        adjustHeap(arr, i, arr.size());
    }
    int n = arr.size();
    while (n-1) {
        swap(arr[0], arr[n - 1]);
        adjustHeap(arr, 0, n-1);
        n--;
    }
}
void print(vector<int>& vec) {
    for (auto i : vec) {
        cout << i << " ";
    }
    return;
}
int main() {
    vector<int> vec = { 9,8,3,7,6,4,5,1,2,0 };
    heapSort(vec);
    print(vec);
    return 0;
}

快速排序1

链接: link.

//快速排序
vector<int> kpSort(vector<int>& vec, int left, int right) {
    int i = left - 1, j = right + 1, index = left;
    vector<int> res;
    int tmp = vec[left];
    while (index < j) {
        if (vec[index] < tmp) {
            i++;
            swap(vec[index], vec[i]);
            index++;
        }
        else if (vec[index] == tmp) {
            index++;
        }
        else {
            j--;
            swap(vec[index], vec[j]);
        }
    }
    res.push_back(i);
    res.push_back(j);
    return res;
}

void quickSort(vector<int>& vec, int left, int right) {
    //判断跳出条件
    if (left >= right) {
        return;
    }
    vector<int> res = kpSort(vec, left, right);
    //res[0]==i    res[1]==j
    //<=i   left到i
    //>j && <j  
    //>=j
    quickSort(vec, left, res[0]);
    quickSort(vec, res[1], right);
}

int main() {
    vector<int> vec = { 1,3,5,6,2,2,3,4,6,9,9,9,4,3,5,2,1,0};

    quickSort(vec,0,vec.size()-1);
    print(vec);
    return 0;
}

快速排序1删减

//快速排序
void quickSort(vector<int>& vec,int left,int right) {
    if (left >= right) {
        return;
    }
    int i = left - 1;
    int j = right + 1;
    int index = left;
    int tmp = vec[left];
    while (index<j) {
        if (vec[index] < tmp) {
            swap(vec[index++] ,vec[++i]);
        }
        else if(vec[index]==tmp){
            index++;
        }
        else {
            swap(vec[index], vec[--j]);
        }
    }
    quickSort(vec,left,i);
    quickSort(vec,j,right);
}

int main() {
    vector<int> vec = { 1,3,5,6,2,2,3,4,6,9,9,9,4,3,5,2,1,0};
    quickSort(vec,0,vec.size()-1);

    print(vec);
    return 0;
}

快速排序2

void quickSort2(int* arr, int left, int right) {
	if (left >= right||!arr) {
		return;
	}
	int mid = 0;
	int begin = left;
	int end = right;
	int key = arr[begin];
	while (begin < end) {
		while (begin < end && arr[end] > key) {
			end--;
		}
		arr[begin] = arr[end];
		while (begin < end && arr[begin] < key) {
			begin++;
		}
		arr[end] = arr[begin];
	}
	arr[begin] = key;
	mid = begin;
	quickSort2(arr, left, mid - 1);
	quickSort2(arr, mid+1, right);
}

归并排序

//归并排序
void merge(vector<int>& vec,int begin,int mid, int end) {
    int i = begin, j = mid + 1, index = 0;
    int* help = new int[end-begin+1];
    while (i <= mid && j <= end) {
        if (vec[i] < vec[j]) {
            help[index++] = vec[i++];
        }
        else {
            help[index++] = vec[j++];
        }
    }
    while (i <= mid) {
        help[index++] = vec[i++];
    }
    while (j <= end) {
        help[index++] = vec[j++];
    }
    index = begin;
    for (int i = 0; i <= end - begin; i++) {
        vec[index++] = help[i];
    }
}
void mergeSort(vector<int>& vec, int begin, int end) {
    if (begin >= end) {
        return;
    }
    int mid = (begin + end) / 2;
    mergeSort(vec, begin, mid);
    mergeSort(vec, mid + 1, end);
    merge(vec,begin,mid,end);
}

int main() {
    vector<int> vec = { 1,3,5,6,2,2,3,4,6,9,9,9,4,3,5,2,1,0};
    mergeSort(vec,0,vec.size()-1);

    print(vec);
    return 0;
}