/*已知一个排好序的数组，按数组原排序方式插入一个数据*/

	/*已知一个排好序的数组，按数组原排序方式插入一个数据*/
	std::vector<int>shuzu = {1,2,3,4,5,7,8,9};
	int x = 0, caru = 6;
	std::vector<int>::iterator iter;
	for (iter = shuzu.begin(); iter != shuzu.end(); iter++)
	{
		if (*iter > caru)break;
		x++;
	}
	shuzu.insert(shuzu.begin() + x, caru);
	x = 0;
	for (iter = shuzu.begin(); iter != shuzu.end(); iter++)
	std::cout << "#" << x++ << ":" << *iter << std::endl;

2020年9月27日，有人看，我也看，突然想能否写出折半查找法，因为，我一直没用一个排好序的数组写过折半查找法，为此在之上代码基础上修改，查阅资料写了如下折半查找算法，只是设计完成，没去优化。

void 按数组原排序方式插入一个数据()
{//修改为O(n/2)折半查找法，先获取数组中间值判断大小从而选择寻找方向，不包含整个算法时间复杂度，整个算法时间复杂度O(n+n/2)。
	std::vector<int>shuzu = { 1, 2, 3, 4, 5, 7, 8, 9 };
	int caru = 10, z = shuzu.at(shuzu.size() / 2 - 1)>caru ? 1 : 0, x = z ? 0 : shuzu.size() - 1;
	std::vector<int>::iterator iter;
	for (iter = z ? shuzu.begin() : --shuzu.end(); iter != (z ? shuzu.end() : shuzu.begin()); z ? iter++ : iter--)
		if (z ? *iter > caru:*iter < caru) break; else z ? ++x : --x;
	shuzu.insert(shuzu.begin() + x + (z ? 0 : 1), caru);
	x = 0;
	for (iter = shuzu.begin(); iter != shuzu.end(); iter++)
		std::cout << "#" << x++ << ":" << *iter << std::endl;
}

2020年9月29日，忽然想起能否不断地二分下去，直到缩小到某范围为止，于是，写了如下循环二分法，称为二分分法：

void 按数组原排序方式插入一个数据2分分法(int 数 = 14)
{//缘由https://mp.csdn.net/console/editor/html/46706509
	//修改为循环二分法，只要范围大等于2就不停二分，以进一步缩小最终查找的循环。
	std::vector<int>shuzu = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,  15, 16, 17, 18, 19, 20 };
	int dx = shuzu.size(), ef = dx / 2, ca = ef;
	while (ca > 2)
		if (shuzu.at(ef)>数)
			ef -= ca /= 2;//往前
		else
			ef += ca /= 2;//往后
	while (shuzu.at(ef) > 数)--ef;
	while (shuzu.at(ef) < 数)++ef;
	shuzu.insert(shuzu.begin() + ef, 数);
	ca = 0;
	while (ca <= dx)cout << shuzu.at(ca++) << ends;
	cout << endl;
}

初测1000个数据插入一个数据最多循环14次，10000个数据插入一个数据最多循环17次，这里的循环量指的是找到位置。

void 按数组原排序插入分分法(vector<int>shuzu, int 数 = 14)
{//缘由https://mp.csdn.net/console/editor/html/46706509
	//修改为循环二分法，只要范围大等于2就不停二分，以进一步缩小最终查找的循环。
	int dx = shuzu.size(), ef = dx / 2, ca = ef, t=0,z=0;
	bool 升 = shuzu.at(0) < shuzu.at(1);
	while (ca > 1)
		if (升 ? shuzu.at(ef) > 数 : shuzu.at(ef) < 数)
			ef -= ca /= 2,++t;//往前
		else
			ef += ca /= 2,++t;//往后
	while (升 ? shuzu.at(ef) > 数 : shuzu.at(ef) < 数)--ef, ++z;
	while (升 ? shuzu.at(ef) < 数 : shuzu.at(ef) > 数)++ef, ++z;
	shuzu.insert(shuzu.begin() + ef, 数);
	ca = 0;
	while (ca <= dx)cout << shuzu.at(ca++) << ends;
	cout <<t<<ends<<z<< endl;
}



	std::vector<int>shuzu = { 1 };
	int a = 1, aa = 47, aaa = 0;
	while (a < aa)shuzu.insert(shuzu.begin() + (a - 1), ++a + ++aaa);
	a = 0;
	while (a < aa + aaa)按数组原序插入分分法(shuzu, ++a);

八大排序法动画参考 2020年10月2日依据之上算法为基础可提高直接插入排序法效率【依据推理应在O(n)至O(n*n/2)初测O(n)至O(n*n/3)】，插入排序法最大缺点移动次数太多。函数原型void 定分直插排序法(int 数组[], int 数, int 位);