经典排序算法

冒泡排序

template<typename T>
//整数或浮点数皆可使用
void bubble_sort(T arr[], int len)
{
    int i, j;  T temp;
    for (i = 0; i < len - 1; i++) { 
        bool flag = false;   
        for (j = 0; j < len - 1 -i; j++) { 
          if (arr[j] > arr[j + 1])
          {
              temp = arr[j];
              arr[j] = arr[j + 1];
              arr[j + 1] = temp;
              flag = true;
          }
        }
        if (flag == true)
          break;    // 剪枝操作
    }
}
int main()
{
    int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
    int len = (int) sizeof(arr) / sizeof(*arr);
    bubble_sort(arr, len);
    for (int i = 0; i < len; i++)
        cout << arr[i] << ' ';
 
    cout << endl;
 
    float arrf[] = { 17.5, 19.1, 0.6, 1.9, 10.5, 12.4, 3.8, 19.7, 1.5, 25.4, 28.6, 4.4, 23.8, 5.4 };
    len = (int) sizeof(arrf) / sizeof(*arrf);
    bubble_sort(arrf, len);
    for (int i = 0; i < len; i++)
        cout << arrf[i] << ' ';
}

快排

快排1

#include <iostream>
 
using namespace std;
 
void Qsort(int arr[], int low, int high){
    if (high <= low) return;
    int i = low ;
    int j = high + 1 ;
    int key = arr[low];
    while (true)
    {
        /*从左向右找比key大的值*/
        // i = 8;
        // ++i = 9; arr[++i] < key 这个条件符合 i = 9 
        //question : 如果 
        while (arr[++i] < key)
        {
            if (i == high){
                break;
            }
        }        
        /*从右向左找比key小的值*/
        while (arr[--j] > key)
        {
            if (j == low){
                break;
            }
        }
        if (i > j) break;
        /*交换i,j对应的值*/
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    /*中枢值与j对应值交换*/
    int temp = arr[low];
    arr[low] = arr[j];
    arr[j] = temp;
    Qsort(arr, low, j - 1);
    Qsort(arr, j + 1, high);
}
 
int main()
{
    int a[] = {57, 68, 59, 52, 72, 28, 96, 33, 24};
    /*
    low                            high
    57, 24, 59, 52, 72, 28, 96, 33, 68
        i                           j
    57, 24, 33, 52, 72, 28, 96, 59, 68
            i                   j
    57, 24, 33, 52, 28, 72, 96, 59, 68
                    i   j
    57, 24, 33, 52, 28, 72, 96, 59, 68  
                    j   i                 i丛左向右搜索找到合适的大于key值的a[i] ,j从右向左检索到合适的大于key值的a[j]
                                          但是i > j ,导致a[i] 与 a[j] 不会引起交换，而且这次分类结束，break 跳出while 
                                          循环。  
    28, 24, 33, 52, 57, 72, 96, 59, 68 
                    j   i             a[low] 和 a[j] 换一下位置

    */
    Qsort(a, 0, sizeof(a) / sizeof(a[0]) - 1);/*这里原文第三个参数要减1否则内存越界*/
 
    for(int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
    {
        cout << a[i] << "    ";
    }
    system("pause");
}/*参考数据结构p274(清华大学出版社，严蔚敏)*/

快排2

#include<vector>
#include<iostream>
using namespace std;
//快速排序（从小到大）
void quickSort(int left, int right, vector<int>& arr )
{
	if (left >= right)
		return;
	int i, j, base, temp;
	i = left, j = right;
	base = arr[left];  //取最左边的数为基准数
	while (i < j)
	{
		// 顺序不能颠倒
		while (arr[j] >= base && i < j)
			j--;
		while (arr[i] <= base && i < j)
			i++;
		if (i < j)
		{
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	//基准数归位
	arr[left] = arr[j];
	arr[j] = base;
	quickSort(left, j - 1, arr);//递归左边
	quickSort(j + 1, right, arr);//递归右边
}

举个例子 7 0 1 2 10 11 22 key取7你让i先++的话i就会走到10最后key归位的时候就会交换10和7

int main() {
	vector<int> arr = { 4,2,7,36,743,23,47,3,23,33,7,33 };
	int length = arr.size();
	quickSort(0, length-1, arr);
	for (auto num : arr)
		cout << num << "  ";
	cout << endl;
	return 0;
}

归并排序

void MergeSort (int arr [], int low,int high) {
    if(low>=high) { return; } // 终止递归的条件，子序列长度为1
    int mid =  low + (high - low)/2;  // 取得序列中间的元素
    MergeSort(arr,low,mid);  // 对左半边递归
    MergeSort(arr,mid+1,high);  // 对右半边递归
    merge(arr,low,mid,high);  // 合并
}

void Merge(int arr[],int low,int mid,int high) {
    //low为第1有序区的第1个元素，i指向第1个元素, mid为第1有序区的最后1个元素
    int i=low,j=mid+1,k=0;  //mid+1为第2有序区第1个元素，j指向第1个元素
    int *temp=new int[high-low+1]; //temp数组暂存合并的有序序列
    while(i<=mid&&j<=high){
        if(arr[i]<=arr[j]) //较小的先存入temp中
            temp[k++]=arr[i++];
        else
            temp[k++]=arr[j++];
    }
    while(i<=mid)//若比较完之后，第一个有序区仍有剩余，则直接复制到t数组中
        temp[k++]=arr[i++];
    while(j<=high)//同上
        temp[k++]=arr[j++];
    for(i=low,k=0;i<=high;i++,k++)//将排好序的存回arr中low到high这区间
	arr[i]=temp[k];
    delete []temp;//释放内存，由于指向的是数组，必须用delete []
}

插入排序

#include<iostream>
#include<cstdlib>
 
using namespace std;
 
//交换数组元素位置位置
void swap(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}
 
 
/*
插入排序。注意，若后面一个元素比其前面一个元素小，则将这两个元素交换位置，然后再来比较这个插入元素与前面一个元素的大小，若小，则还需要交换这两个元素位置，一直到这个插入元素在正确的位置为止
*/
void insertSort(int a[],  int length)
{
	for (int i = 1; i < length; i++)
	{
		for (int j = i - 1; j >= 0 && a[j + 1] < a[j]; j--)
		{
			swap(a[j], a[j + 1]);
		}
	}
 
}
 
int main()
{
	int a[] = { 2,1,4,5,3,8,7,9,0,6 };
 
	insertSort(a, 10);
 
	for (int i = 0; i < 10; i++)
	{
		cout << a[i] << "";
 
	}
	cout << endl;
	system("pause");
	return 0;
 
}

shell 排序

#include<iostream>
 
using namespace std;
const int INCRGAP = 3;
void shellsort1(int a[], int n)
{
    int i, j, gap;

    for (gap = n / 2; gap > 0; gap /= 2) //步长
        for (i = 0; i < gap; i++)        //直接插入排序
        {
            for (j = i + gap; j < n; j += gap) 
                if (a[j] < a[j - gap])
                {
                    int temp = a[j];
                    int k = j - gap;
                    while (k >= 0 && a[k] > temp)
                    {
                        a[k + gap] = a[k];
                        k -= gap;
                    }
                    a[k + gap] = temp;
                }
        }
}
int main()
{
    int array[11] = {2, 1, 4, 3, 11, 6, 5, 7, 8, 10, 15};
    shellSort(array, 11);
    for(auto it: array)
    {
        cout<<it<<endl;
    }
    return 0;
}

堆排

#include <iostream>
#include <algorithm>
using namespace std;


void max_heapify(int arr[], int start, int end) {
    int dad = start; int son = dad * 2 + 1;

    while ( son <= end ){
        if (son + 1 <= end && arr[son] < arr[son+1]){
            son++;
        }
        if (arr[dad] > arr[son]){
            return;
        } else {
            swap(arr[dad], arr[son]);
            dad = son; 
            son = dad * 2 + 1;
        }
    }
}

void heap_sort(int arr[], int length){
    for(int i = length / 2 - 1; i >= 0; i--){
        max_heapify(arr, i, length-1);  // 这样的话是大堆顶
    }
    for(int i = length - 1; i >= 0; i--){
        swap(arr[0], arr[i]);
        max_heapify(arr,0,i-1);
    }

}

int main(){
    int arr[] = { 4,6,1,32,56,7,2,3,5,3};
    int length  = sizeof(arr) / sizeof(*arr);
    heap_sort(arr, length);
    for(int i = 0; i < length; i++){
        cout << arr[i]  << "   ";
    }
    system("pause");
    return 0;
}