C++排序的介绍

一、交换类

冒泡排序

遍历每一个位置，将它与其下一位的值比较，按照大小选择是否交换

int main(){
    int i;//初始化i
    int arr[10] = {1,5,6,3,9,7,2,8,4,0};//初始化数组
    for(int i = 0, i<9, i++){//10位数字，需要执行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;//交换前后值
            }
        }
    }
}
                

快速排序

设定中间值，把数组中比中间值大的数放在其右边，小的放在左边

再将左子序列或者右子序列重复进行上面的操作，直至左子序列或者右子序列的数字为1

void quickSort(int a[], int, int);//声明函数
int main()
{
	int array[] = { 32,64,12,43,69,5,78,10,3,70 },k;
	int len = sizeof(array) / sizeof(int);//数组长度
//cout << len << endl;
	cout << "The orginal arrayare:" << endl;
	for ( k = 0; k<len; k++)
		cout << array[k] << " ";
	cout << endl;

	quickSort(array, 0, len - 1);
	cout << "The sorted arrayare:" << endl;
	for (k = 0; k<len; k++)
		cout << array[k] << " ";//打印数组
	cout << endl;
	system("pause");
	return 0;
}

void quickSort(int s[], int l, int r)//定义quicksort
{
	if (l< r)
	{
		int i = l, j = r, x = s[l];
		while (i < j)
		{
			while (i < j && s[j] >= x) // 从右向左找第一个小于x的数
				j--;
			if (i < j)
				s[i++] = s[j];
			while (i < j && s[i]< x) // 从左向右找第一个大于等于x的数
				i++;
			if (i < j)
				s[j--] = s[i];
		}
		s[i] = x;
		quickSort(s, l, i - 1); // 递归调用
		quickSort(s, i + 1, r);
	}
}

二、选择类

选择排序

遍历每一个位置，将该位置的数与之后的值比较，发现有较小/大值则交换（可找出该循环下最小/大值）

int main(){
    int arr[10] = {1,5,6,3,9,7,2,8,4,0};//初始化数组
    for(int i = 0, i < 10, i++){//外循环
        for(int j = 0, j < 10, j++){//内循环
            if(arr[j] > arr[i]{//判断条件
                int temp = arr[i];
                arr[j] = arr[i];
                arr[i] = temp;//交换值
            }
        }
    }
}

堆排序

建立堆–将n个元素组成的无序序列构建一个堆，
交换堆元素–交换堆尾元素和堆首元素，使堆尾元素为最大元素；
重建堆–将前n-1个元素组成的无序序列调整为堆

void adjust(int arr[], int len, int index)
{
	int left = 2 * index + 1;
	int right = 2 * index + 2;
	int max = index;
	if (left<len && arr[left] > arr[max]) max = left;
	if (right<len && arr[right] > arr[max]) max = right;  // max是3个数中最大数的下标
	if (max != index)                 // 如果max的值有更新
	{
		swap(arr[max], arr[index]);
		adjust(arr, len, max);       // 递归调整其他不满足堆性质的部分
	}

}
void heapSort(int arr[], int size)
{
	for (int i = size / 2 - 1; i >= 0; i--)  // 对每一个非叶结点进行堆调整(从最后一个非叶结点开始)
	{
		adjust(arr, size, i);
	}
	for (int i = size - 1; i >= 1; i--)
	{
		swap(arr[0], arr[i]);           // 将当前最大的放置到数组末尾
		adjust(arr, i, 0);              // 将未完成排序的部分继续进行堆排序
	}
}

int main()
{
	int array[8] = { 6, 0, 15, 4, 21, 5, 7, 10 };
	heapSort(array, 8);
	for (auto it : array)
	{
		cout << it << endl;
	}
	system("pause");
	return 0;
}

三、插入类

插入排序

遍历从第二个位置开始的每一位数，将其与前面所有数比较，如果小于/大于，则将其插入前面；如此遍历前面所有位置

int main(){
    int(10) =  {1,5,6,3,9,7,2,8,4,0};
    for (int i = 1, i < 10, i++){
        for(int j = i, j > 0, j--){
            if (arr[j - 1] > arr[j]{
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
            }
        }
    }
}

希尔排序

需要先定义一个gap，从第gap个数开始每隔一个gap取一个数进行比较

第二轮则从gap+1开始，直至结尾；再将gap倍减，重复操作

int main() {
    arr[10] =  {1,5,6,3,9,7,2,8,4,0}
	for (int gap = 4; gap > 0; gap /=2){//定义一个空隙为4，依次减倍
		for (int i = gap; i < 15; i++) {

			for (int j = i; j >gap - 1; j -= gap) {//从第0个数开始，每隔4个数进行两两比较
				if (arr[j - gap]>arr[j]) {
					int temp = arr[j - gap];
					arr[j - gap] = arr[j];
					arr[j] = temp;
				}
			}
		}
	}
}

四、归并类

归并排序

设定一个中间值，把数组分成两组

int main() {
	int arr[10] = {1,5,6,3,9,7,2,8,4,0};
	int mid = 10 / 2;//设定一个中间值，把数组分成两组（假定两组已排好序）
	int i=0,j=mid+1, k=0;//设定三个变量，i,j表示两组数组的开始位置
	int temp[10] = {};//定义一个全新的数组，用来存放数
	while (i <= mid&&j < 7) {//判断i,j的值是否到达临界
		if (arr[i] < arr[j]) {
			temp[k] = arr[i];
			k++;
			i++;
			

		}
		else {
			temp[k] = arr[j];
			k++;
			j++;
		}
	}
}

五、分配类

计数排序（非比较类）

首先需要定义两个数组，一个用于存放数字种类的个数，另一个用于存放排好序的数组

然后遍历整个数组，记录下数组中各数字的个数存放于第一个数组中

int arr[] = {3,2,3,1,5,6,8,6}, temp[1001], result[1001], n;
int main() {
	int len = sizeof(arr)/sizeof(int);//数组长度
	cout << len << endl;
	//cin >> n;
	for (int i = 0; i < len; i++)
	{
		temp[arr[i]]++;
	}
	for (int i = 0; i < len; i++)
	{
		temp[i+1]+=temp[i];
	}
	for (int i = len - 1; i >= 0; i--)
	{
		result[--temp[arr[i]]] = arr[i];
	}
	for (int i = 0; i < len; i++)//打印数组
	{
		
		cout << result[i] << " ";
	}
	system("pause");
	return 0;
}

基数排序

假定一组数只有三位数组成，先将个位上的数按顺序好，如个位上是1就放在数组index为1的数组

将个位上排好序之后，将数从上到下取出来（先进先出）进行十位上的排序，再进行百位上的排序三轮排序之后就会呈现出一个有序的数组

void printArray(int array[], int length)
{
	for (int i = 0; i < length; ++i)
	{
		cout << array[i] << " ";
	}
	cout << endl;
}
//求数据的最大位数,决定排序次数

int maxbit(int data[], int n)
{
	int d = 1; //保存最大的位数
	int p = 10;
	for (int i = 0; i < n; ++i)
	{
		while (data[i] >= p)
		{
			p *= 10;
			++d;
		}
	}
	return d;
}
void radixsort(int data[], int n) //基数排序
{
	int d = maxbit(data, n);
	int temp[10];
	int count[10]; //计数器
	int i, j, k;
	int radix = 1;
	for (i = 1; i <= d; i++) //进行d次排序
	{
		for (j = 0; j < 10; j++)
			count[j] = 0; //每次分配前清空计数器
		for (j = 0; j < n; j++)
		{
			k = (data[j] / radix) % 10; //统计每个桶中的记录数
			count[k]++;
		}
		for (j = 1; j < 10; j++)
			count[j] = count[j - 1] + count[j]; //将temp中的位置依次分配给每个桶
		for (j = n - 1; j >= 0; j--) //将所有桶中记录依次收集到temp中
		{
			k = (data[j] / radix) % 10;
			temp[count[k] - 1] = data[j];
			count[k]--;
		}
		for (j = 0; j < n; j++) //将临时数组的内容复制到data中
			data[j] = temp[j];
		radix = radix * 10;
	}
}

int main()
{
	int array[10] = { 73,22,93,43,55,14,28,65,39,81 };
	radixsort(array, 10);
	printArray(array, 10);
	system("pause");
	return 0;
}