备战蓝桥杯第二模块之七大排序

前言

本系列是我学习完大佬的方法后，为了蓝桥杯前几天可以快速过一遍所做，所以部分内容会很简洁。如果能够帮助到你，我也会很开心！！！

做题

题目中可以直接使用sort/qsort函数来节约时间

sort(arr,arr+10,排序方法)
//第三个参数不写时,默认按照升序排列
sort(arr,arr+10, greater<int>()); 
//降序排列

 qsort (arr, sizeof(arr)/sizeof(arr[0]), sizeof(int), compare);
//sizeof(arr)/sizeof(arr[0]) 数组中元素的数目

冒泡排序

void BubbleSort(int* a, int n)
{
	for (int i = 0; i < n; i++)
	{
		int flag = 0;
		for (int j = 0; j < n - i - 1; j++)
		{
			if (a[j] < a[j + 1])
			{
				flag = 1;
				swap(a[j], a[j + 1]);
			}
			
		}
		if (flag == 0)
			break;
	}
}

选择排序

选出最大的，放在最后面，然后再开始一轮新的排序

void Select(int* a, int n)
{
	for (int i = n; i >= 1; i--)
	{
		int max = 1;
		for (int j = 1; j <= i; j++)
		{
			if (a[j] > a[max])
			{
				max = j;
			}

		}
		swap(a[max], a[i]);
	}

}

插入排序

j=i是因为前面的元素已经有序

void InsertSort(int* a, int n)//n是大小
{
	for (int i = 2; i < n; i++)
	{
		int val = a[i];//要插入的值
		int j;//要插入的位置
		for (j = i; j > 1 && val < a[j - 1]; j--)//将大于val的值后移
		{
			a[j] = a[j - 1];//把a[j - 1]向后挪动
		}
		a[j] = val;
	}
}

归并排序

void merge_sort(int a[], int l, int r) {
    if (l >= r) return;
    int mid = (l + r) / 2;
    merge_sort(a, l, mid - 1);
    merge_sort(a, mid + 1, r);
    int k =0;
    int i =l;
    int j =mid+1;
    while (i<=mid && j <= r)
    {
        if (a[i] <= a[j]) tmp[k++] = a[i++];
        else {
            tmp[k++] = a[j++];
           // cnt += mid - i + 1;省略的这个是求得逆序数（前面的数大于乐后面的数）
        }
    }
    while (i <= mid) tmp[k++] = a[i++];
    while (j <= r) tmp[k++] = a[j++];
    }
}

快速排序

int Partition(int a[], int l, int r)
{
	int pivot = a[r];//基准
	int i = l;
	int j = r;
	while (l < r)
	{
		while (i < j && a[i] <= pivot)
			i++;//左边的比基准小，继续遍历
		while (i < j && a[j] >= pivot)
			j--;
		if (i < j)
			swap(a[i], a[j]);
		else
			swap(a[i], a[r]);

	}
 }
void QuickSort(int a[], int l, int r)
{
	if (l < r)
	{
		int  mid = Partition(a , l, r);
		QuickSort(a, l, mid - 1);
		QuickSort(a, mid + 1,r);
	}
}

桶排序

适用于数据量大且数据值比较少

void bucketSort(int arr[], int n) {
    // 初始化桶
    int bucket[MAX_VALUE + 1] = {0};
    // 将数据放入桶中（核心代买）
    for (int i = 0; i < n; i++) {
        bucket[arr[i]]++;
        /*int x;
        cin >> x;
        bucket[x]++;*/
    }
    int index = 0;

        for (int i = 0; i <= MAX_VALUE; i++)
        for (int j = 1; j <= bucket[i]; j++) 
        {
            cout << i << " ";
        }
    
}

堆排序

堆排序包括建堆和堆调整。

void heapify(vector<int>& arr, int n, int i) {
    int largest = i; // 初始化最大值为根
    int left = 2 * i + 1; // 左子节点
    int right = 2 * i + 2; // 右子节点
    // 如果左子节点比根大
    if (left < n && arr[left] > arr[largest])
        largest = left;
    // 如果右子节点比目前已知的最大值还大
    if (right < n && arr[right] > arr[largest])
        largest = right;
    // 如果最大值不是根
    if (largest != i) {
        swap(arr[i], arr[largest]);
        // 递归地调整受影响的子堆
        heapify(arr, n, largest);
    }
}
// 堆排序函数
void heapSort(vector<int>& arr) {
    // 建大顶堆
    int n = arr.size();
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);
    // 一个一个从堆顶取出元素
    for (int i = n - 1; i >= 0; i--) {
        swap(arr[0], arr[i]); // 将当前最大元素arr[0]放到末尾
        heapify(arr, i, 0); // 重新对堆进行调整
    }
}