桶排序、数组知识强化、VS2019快捷键、类

快捷键：

Ctrl + F5：查找

Ctrl + K和Ctrl + C：注释代码

Ctrl + K和Ctrl + U：取消注释

shift+方向键：向各个方向选中

双Tab：自动补全代码

Ctrl + 左右键：移动整个单词

home：一行的开头。 -- Ctrl + home：文档开头

end：一行的结尾。 -- Ctrl + end：文档结尾

Page Up：上翻一页

Page Down：下翻一页

Ctrl + K和Ctrl + D： 格式化整个代码

Ctrl + K和Ctrl + F：格式化选中的代码

桶排序：

#include<iostream>
#include<cmath>
#include<ctime>
using namespace std;
#define NUMMAX 10000
#define BUCKETMAX 10

typedef int Type;
//生成10000个数据
void test(Type arrNum[], int arrNumMax)
{
	for (int i = 0; i < arrNumMax; i++)
	{
		int num = rand() % 1000;
		arrNum[i] = num;
	}
}
//打印数据
void showArray(Type arrNum[], int arrNumMax)
{
	for (int i = 0; i < arrNumMax; i++)
	{
		cout << arrNum[i] << "\t";
	}
}
//桶子的大小
void newBucket(Type* arrBucketAddr[], int arrBucketMax, int arrNumMax)
{
	int i = 0;
	for (i = 0; i < arrBucketMax; i++)
	{
		arrBucketAddr[i] = new Type[arrNumMax];
	}
}
//把数据倒入桶子内
void sort_Num_TO_Bucket(Type arrNum[], int arrNumMax, Type* arrBucketAddr[],
	int arrBucketAddrMax, int BucketFlag[], int way, int now_Digits)
{
	int i = 0;
	int j = 0;
	if (way == 1)
	{
		for (i = 0; i < arrNumMax; i++)
		{
			for (j = 0; j < arrBucketAddrMax; j++)
			{
				//pow：对应的数据类型为double，这里需要强制转化为int
				//按照个位来进行分类
				if (arrNum[i] / (int)pow(10, now_Digits) % 10 == j)
				{
					//*arrBucketAddr为桶子的地址，**arrBucketAddr为桶子的内存空间
					*(arrBucketAddr[j] + BucketFlag[j]) = arrNum[i];
					BucketFlag[j]++;
					break;
				}
			}
		}
	}
}

//把桶内的数据倒出来
void sort_Bucket_To_Num(Type arrNum[], int arrNumMax, Type* arrBucketAddr[], int arrBucketAddrMax, int BucketFlag[])
{
	int i, j, k;
	for (i = 0; i < arrNumMax;)
	{
		for (j = 0; j < arrBucketAddrMax; j++)
		{
			for (k = 0; k < BucketFlag[j]; k++)
			{
				arrNum[i] = *(arrBucketAddr[j] + k);
				i++;
			}
			BucketFlag[j] = 0;
		}
	}
}
//找到最大值
Type findMax(Type arrNum[], int arrNumMax)
{
	int i = 0;
	Type max = arrNum[0];
	for (i = 0; i < arrNumMax; i++)
	{
		if (arrNum[i] > max)
		{
			max = arrNum[i];
		}
	}
	return max;
}
//计算位数
int calc_Digits(Type num) //计算数据的位数
{
	int i = 0;
	if (num == 0)
		return 1;
	for (i = 0; num != 0; num /= 10, i++);
	return i;
}

//桶排序
void bucketSort(Type arrNum[], int arrNumMax, int way)
{
	//在堆区开辟桶的空间，arrBucket存储桶的地址
	Type** arrBucketAddr = new Type * [BUCKETMAX];
	//每个桶存储的数据数量
	int BucketFlag[BUCKETMAX] = { 0 };

	newBucket(arrBucketAddr, BUCKETMAX, arrNumMax);
	Type max = findMax(arrNum, arrNumMax);
	int maxDigits = calc_Digits(max);

	for (int now_Digits = 0; now_Digits < maxDigits; now_Digits++)
	{
		//第一次先按照个位将数据放入桶子内，然后依次倒出
		//第二次按照十位将数据放入桶子内，然后依次从0号桶子开始倒
		//第三次按照百位将数据放入桶子内，倒出数据，数据排列完毕
		sort_Num_TO_Bucket(arrNum, arrNumMax, arrBucketAddr, BUCKETMAX, BucketFlag, way, now_Digits);
		sort_Bucket_To_Num(arrNum, arrNumMax, arrBucketAddr, BUCKETMAX, BucketFlag);
	}
	delete arrBucketAddr;
}

int main()
{
	srand((unsigned int)time(NULL));

	//arrNum用于存放要排序的数据
	Type* arrNum = new Type[NUMMAX];
	test(arrNum, NUMMAX);
	bucketSort(arrNum, NUMMAX, 1);
	showArray(arrNum, NUMMAX);

	delete arrNum;
	return EXIT_SUCCESS;
}

桶排序的关键：有几位数，就重复几次。一次：把数据先倒入桶内，在倒出桶，表示一次。

先按个位进行倒入倒出，再十位，再百位，以此类推。

数组强化知识：

arr[0]+1，在for循环中，输出结果都是0，因为arr数组{0}只有一个0，为全局变量，在循环一次完毕后，输出的是全局变量中的数值

 

将arr[0]+1改成arr[0]++，意思就是arr数组中第一个数做自增。

类：

在C++中，类和结构体唯一的区别就是默认的访问权限不同

类的默认权限：私有权限（类内可以访问，类外不可以访问）

结构体默认权限：公共权限（类内可以访问，类外也可以访问）

#include<iostream>
using namespace std;

/*
public：公共权限	类内可以访问 类外也可以访问
protected：保护权限	类内可以访问 类外不可以访问
private：私有权限	类内可以访问 类外不可以访问
*/

int main()
{
    /*语法：
	class Student
    {
        权限类型：
            行为（即函数体）
            属性（类的属性值）
    };

    */
	return EXIT_SUCCESS;
}