c++排序

1.冒泡排序

#include<iostream>
using namespace std;
int main() {
	
	int i;
	int arr[10] = { 1,5,2,3,6,8,7,9,4 ,0};//初始化数组
	for (int i = 0; i < 9;i++) {//一共循环10次

		for (int j = 0; j < 9-i; j++) {//执行的次数依次递减
			if (arr[j]>arr[j + 1]) {
				int temp = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = temp;//交换值
			}
		}
	}
					
	for (int j = 0; j < 10; j++)//打印数组
	{
		cout << arr[j] << endl;
	}
	system("pause");
	return 0;
}

2.选择排序

void BSortMethod::selectionSort(int *vec, int len)
{
    for ( int i = 0; i < len - 1; ++i )
    {
        int minIndex = i;

        // 每次遍历找到最小值的索引
        for ( int j = i + 1; j < len; ++j )
        {
            if ( vec[j] < vec[minIndex] ) {
                minIndex = j;
            }
        }

        // 把最小值放在有序序列的最后
        if ( minIndex != i ) {
            int temp = vec[minIndex];
            vec[minIndex] = vec[i];
            vec[i] = temp;
        }
    }
}

3.插入排序

void BSortMethod::insertionSort(int *vec, int len)
{
    for ( int i = 0; i < len; ++i )
    {
        int preIndex = i - 1;
        int currentValue = vec[i];

        // 从后往前遍历有序列表，直到找到比当前数值小或者相等的数的索引，我们在这个索引后插入 currentValue
        while ( preIndex >= 0 && vec[preIndex] > currentValue )
        {
            vec[preIndex + 1] = vec[preIndex];
            preIndex--;
        }

        vec[preIndex+1] = currentValue;
    }
}

4.希尔排序

void BSortMethod::shellSort(int *vec, int len)
{
    // 初始增量 gap = len / 2，逐渐缩小增量 gap = gap / 2 直到变为 1
    for ( int gap = len / 2; gap >=1; gap = gap / 2 )
    {
        // 每一组进行排序
        for ( int i = gap; i < len; ++i )
        {
            int temp = vec[i];
            int j = i - gap;

            while ( j >= 0 && vec[j] > temp )
            {
                vec[j+gap] = vec[j];
                j -= gap;
            }

            vec[j+gap] = temp;
        }
    }
}

5.并归排序

void BSortMethod::merge(int *vec, int len)
{
    int mid = len / 2;              // mid将数组从中间分割
    int *arr = new int[len];        // 临时数组（额外的内存空间）
    int s = 0;                      // 临时数组的起始位置
    int first = 0, second = mid;    // 两个数组的起始位置

    while ( first < mid && second < len )
    {
        // 比较大小
        if ( vec[first] <= vec[second] ) {
            arr[s++] = vec[first++];
        } else {
            arr[s++] = vec[second++];
        }
    }

    // 将剩余项复制到临时数组中
    while ( first < mid )
    {
        arr[s++] = vec[first++];
    }

    while ( second < len )
    {
        arr[s++] = vec[second++];
    }

    // 临时数组复制到原数组
    for (int i = 0; i < len; ++i)
    {
        vec[i] = arr[i];
    }
    
    // 内存释放
    delete []arr;
}


void BSortMethod::mergeSort(int *vec, int len)
{
    // 递归出口
    if ( len < 2 ) {
        return;
    }

    mergeSort(vec, len / 2);                    // 对前半部分进行归并排序
    mergeSort(vec + len / 2, len - len / 2);    // 对后半部分进行归并排序
    merge(vec, len);                            // 归并两部分
}

6.快速排序

void BSortMethod::swap(int *vec, int i, int j)
{
    int temp = vec[i];
    vec[i] = vec[j];
    vec[j] = temp;
}


int BSortMethod::partition(int *vec, int left, int right)
{
    int pivot = left;
    int index = pivot + 1;
    int i = index;

    while ( i <= right )
    {
        if ( vec[i] < vec[pivot] ) {
            swap(vec, i, index);
            index += 1;
        }

        i += 1;
    }

    swap(vec, pivot, index - 1);

    // 返回最终划分完成后基准元素所在的位置
    return index - 1;
}


void BSortMethod::quickSort(int *vec, int left, int right)
{
    if ( left < right ) {
        int mid = partition(vec, left, right);
        quickSort(vec, left, mid - 1);
        quickSort(vec, mid + 1, right);
    }
}