20200705八大排序算法 手撕纪要快排归并插入冒泡

1.https://www.jianshu.com/p/e136ec79235c
红黑树的组成 ，旋转，变色
查找 ，插入和删除
先放着 容我把排序手撕搞清楚

2. 开始排序
   （1） 冒泡排序 最简单

void bubbleSort(vector<int> &a)
{
    int len = a.size();
    for (int i = 0; i < len - 1; i++) //需要循环次数
    {
        for (int j = 0; j < len - 1 - i; j++) //每次需要比较个数
        {
            if (a[j] > a[j + 1])
            {
                swap(a[j], a[j + 1]); //不满足偏序，交换
            }
        }
    }
}

自己写的

#include<iostream>
#include<vector>

using namespace std;
void pop_sort(vector<int>& data, int n) {
	int i, j, temp;
	for (i = 0;i < n - 1;i++) {
		for (j = 1;j < n-i;j++) {
			if (data[j - 1] > data[j]) {
				temp = data[j - 1];
				data[j - 1] = data[j];
				data[j] = temp;
			}
		}
	}
}
int main() {
	int n;
	cin >> n;
	vector<int>data(n);
	for (int i = 0;i < n;i++) {
		cin >> data[i];
	}
	pop_sort(data, n);

	for (int i = 0;i < n;i++) {
		cout << data[i] << " ";
	}
	
	return 0;
}

（2）插入排序
就是说对每一个选中的数 插入到合适的位置上去

#include<iostream>
#include<vector>

using namespace std;

int main() {
	int n;
	cin >> n;
	vector<int>data(n);
	for (int i = 0;i < n;i++) {
		cin >> data[i];
	}
	int i, j;
	for (i = 1;i < n;i++) {
		int temp = data[i];
		for (j = i - 1;j >= 0 && data[j] > temp;j--) {
			data[j+1] = data[j];
		}
		data[j+1] = temp;
	}
	for (int i = 0;i < n-1;i++) {
		cout << data[i] << " ";
	}
	cout << data[n - 1]<<endl;
	return 0;
}

（3） 归并排序

归并排序的方法就是说我们需要分而治之 分 治 然后合起来 就这么简单
最后合并的过程就是这个merge函数的层层 返回上层

void merge(int arr[], int left, int mid, int right)
{   
    std::vector<int> *result = new std::vector<int>();
    int l = left;
    int m = mid;
    while(l <= mid -1 && m <= right)
    {  
        if( arr[l] <= arr[m] ){
            result->push_back(arr[l++]);
        }           
        else {
            result->push_back(arr[m++]);
        }   
    }  
    while(l <= mid -1){
        result->push_back(arr[l++]);
    }  
    while(m <= right){
        result->push_back(arr[m++]);
    }
    for(auto item : *result)
    {                                                      
        arr[left++] = item;
    }
}   
    
void mergeSort(int arr[], int left, int right)
{   
    if( right - left < 2) 
    {
        if( arr[left] > arr[right])
        {
            std::swap(arr[left], arr[right]);
        }
        return ;
    }
    int m = (right + left)/ 2 ;
    mergeSort(arr, left, m);
    mergeSort(arr, m+1, right);
    merge(arr, left, m+1, right);
}   
    
int main()
{   
    int test[10];
    for(int i = 0; i < 10; ++i)
    {
        test[i] = std::rand()%100;
    }
    std::cout <<"排序前"<< std::endl;
    for(int i = 0; i < 10; ++i)
    {
        std::cout << test[i]<<" " ;
    }
    std::cout << std::endl;
    mergeSort(test,0,9);
    std::cout <<"排序后"<< std::endl;                                                   
    for(int i = 0; i < 10; ++i)
    {
        std::cout << test[i]<<" " ;
    }
    std::cout << std::endl;
return 0;
} 

参考文献
https://blog.csdn.net/helloworld_ptt/article/details/84332343

（4）快速排序 也是用分治方法

快速排序 这个真的厉害 找一个基准值 然后通过比较交换把小于的和大于的放在两边
继续进行

void quick_sort(vector<int>& data, int low, int high) {
	
	int i, j, pivot;
	if (low < high) {
		i = low;
		j = high;
		pivot = data[low];
		while (i < j) {
			while (i < j && data[j] >= pivot) {
				j--;
			}
			if (i < j) { data[i++] = data[j]; }
			while (i < j && data[i] <= pivot) {
				i++;
			}
			if (i < j) { data[j--] = data[i]; }
		}
		data[i] = pivot;
		quick_sort(data, low, i - 1);
		quick_sort(data, i + 1, high);
	}

}

参考文献
https://www.cnblogs.com/miracleswgm/p/9199124.html

（5） 选择排序

void select_sort(vector<int>& data, int n) {
	int i, j, x, l;
	for (i = 0;i < n;i++) {
		x = data[i];
		l = i;
		for (j = i + 1;j < n;j++) {
			if (data[j] < x) {
				x = data[j];
				l = j;
			}
		}
		data[j] = data[i];
		data[i] = x;
	}

}

（6） 希尔排序
就是分组插入排序
分治思想用在插入排序上

（7 ）堆排序

// 堆排序
// 调整堆，根元素沿树向下移动，直至其合适位置，first和last分别为堆顶和堆底在数组array中的索引
void moveDown(vector<int>& array, int first, int last){
    // first的左子节点索引
    int curIndex = first * 2 + 1;
    while (curIndex <= last){
        // 若first有2子节点，令curIndex为其值最大子节点索引
        if (curIndex < last && array[curIndex] < array[curIndex + 1]){
            curIndex++;
        }
        // 若根节点值小于子节点值，则交换
        if (array[first] < array[curIndex]){
            swap(array[first], array[curIndex]);
            first = curIndex;
            curIndex = first * 2 + 1;
        }
        else{
            break;
        }
    }
}
// 用数组实现堆
void buildHeap(vector<int>& array){
    // 最后一个非叶节点的节点索引
    int i = array.size() / 2 - 1;
    while (i >= 0){
        moveDown(array, i, array.size() - 1);
        i--;
    }
}
// 堆排序
void heapSort(vector<int>& array){
    // 生成堆
    buildHeap(array);
    // 堆顶、底索引
    int first = 0, last = array.size() - 1;
    while (first <= last){
        swap(array[first], array[last]);
        last--;
        moveDown(array, first, last);
    }
}