分治法学习笔记

解题步骤

1. 分解：将要解决的问题分解成若干个规模较小、相互独立、与原问题形式相同的子问题。
2. 治理：求解各个子问题。由于各个子问题与原问题形式相同，只是规模较小而已，当子问题划分得足够小时，就可以用较简单的方法解决。
3. 合并：按原问题的要求，将子问题的解逐层合并并构成原问题的解。
4. 总结：将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。

二分搜索技术

猜数游戏

如果在纸上写上一个10以内的整数，每次猜的数字只能告诉你是比这个大还是比这个小，你要怎样才能以最快的速度猜出来是多少呢？
答： 使用折半查找的策略，每次和中间的元素比较，如果比中间元素小，则在前半部分查找，如果比中间元素大，则去后半部分找。
如： 纸上是8，10以内，那么第一个中间数就是5，5<8，那么6到10的中间数就是8了

代码实现

DeviceConquerUtils.h

 /*
 * BinarySearch.h
 * 分治法工具类
 *  Created on: 2019年2月22日
 *      Author: WEI
 */

#ifndef ALGORITHM_BINARYSEARCH_H_
#define ALGORITHM_BINARYSEARCH_H_

class BinarySearch {
public:
	BinarySearch();
	virtual ~BinarySearch();

	static void test();

private:
	//n是数组元素的个数，s是数组，x是要查询的值//
	static int Func(int n, int s[], int x);
};

#endif /* ALGORITHM_BINARYSEARCH_H_ */

DeviceConquerUtils.cpp

/*
 * BinarySearch.cpp
 *
 *  Created on: 2019年2月22日
 *      Author: WEI
 */

#include "BinarySearch.h"

#include <iostream>
#include <algorithm>

BinarySearch::BinarySearch() {
	// TODO Auto-generated constructor stub

}

BinarySearch::~BinarySearch() {
	// TODO Auto-generated destructor stub
}

void BinarySearch::test() {
	int number=0;//元素个数//
	int s[1000];

	std::cout<<"请输入数列中的元素个数...";
	std::cin>>number;

	std::cout<<"请依次输入数列中的元素..."<<std::endl;
	for(int i=0; i<number; i++)
	{
		std::cin>>s[i];
	}

	std::sort(s, s+number);
	std::cout<<"排序后的数组...";

	for(int i=0; i<number; i++)
	{
		std::cout<<s[i]<<" ";
	}
	std::cout<<std::endl;

	int x;
	std::cout<<"请输入需要查找的元素...";
	std::cin>>x;

	int res=Func(number, s, x);
	if(res==-1)
	{
		std::cout<<"该数列中没有要查找的元素"<<std::endl;
	}
	else
	{
		std::cout<<"要查找的元素在第"<<res+1<<"位"<<std::endl;
	}
}

int BinarySearch::Func(int n, int s[], int x) {
	int low=0;//low指向数组的第一个元素//
	int high=n-1;//high指向数组的最后一个元素//
	while(low<=high)
	{
		int middle=(low+high)/2;//middle为查找范围的中间值//
		if(x==s[middle])
		{
			//如果中间值刚好是需要查询的x值，算法结束//
			return middle;
		}
		else if(x<s[middle])
		{
			//如果x小于查找范围的中间值，那么从前半部分查找//
			high=middle-1;
		}
		else
		{
			//如果x大于查找范围的中间值，那么从后半部分查找//
			low=middle+1;
		}
	}
	return -1;
}

合并排序

介绍

合并排序就是采取分治的策略，将一个大的问题分成很多个小问题，先解决小问题，再通过小问题解决大问题。由于排序问题给定的是一个无序的序列，可以把待排序元素分解成两个规模大致相等的子序列。如果不易解决，再将得到的子序列继续分解，直到子序列中包含的元素个数为1.因为单个元素的序列本身是有序的，此时便可以进行合并，从而得到一个完整的有序序列。

代码实现

MergeSort.h

/*
 * MergeSort.h
 *
 *  Created on: 2019年2月22日
 *      Author: WEI
 */

#ifndef ALGORITHM_MERGESORT_H_
#define ALGORITHM_MERGESORT_H_

class MergeSort {
public:
	MergeSort();
	virtual ~MergeSort();

	static void test();

private:
	//s是数组，low是最低的索引值，high是最高的索引值//
	static int Func(int s[], int low, int high);

	static int Merge(int s[], int low, int mid, int high);
};

#endif /* ALGORITHM_MERGESORT_H_ */

MergeSort.cpp

/*
 * MergeSort.cpp
 *
 *  Created on: 2019年2月22日
 *      Author: WEI
 */

#include "MergeSort.h"

#include <iostream>
#include <algorithm>


MergeSort::MergeSort() {
	// TODO Auto-generated constructor stub

}

MergeSort::~MergeSort() {
	// TODO Auto-generated destructor stub
}

void MergeSort::test() {
	int number=0;//元素个数//
	int s[1000];

	std::cout<<"请输入数列中的元素个数...";
	std::cin>>number;

	std::cout<<"请依次输入数列中的元素..."<<std::endl;
	for(int i=0; i<number; i++)
	{
		std::cin>>s[i];
	}

	Func(s, 0, number-1);

	std::cout<<"合并排序结果..."<<std::endl;
	for(int i=0;i<number;i++)
	{
		std::cout<<s[i]<<" ";
	}
	std::cout<<std::endl;
}

int MergeSort::Func(int s[], int low, int high) {
	if(low<high)
	{
		int mid=(low+high)/2;
		Func(s, low, mid);
		Func(s, mid+1, high);
		Merge(s, low, mid, high);
	}
	return 0;
}

int MergeSort::Merge(int s[], int low, int mid, int high) {
	int *tmp=new int[high-low+1];
	int i=low;
	int j=mid+1;
	int k=0;

	while(i<=mid && j<=high)
	{
		if(s[i]<=s[j])
		{
			tmp[k++]=s[i++];
		}
		else
		{
			tmp[k++]=s[j++];
		}
	}
	while(i<=mid)
	{
		tmp[k++]=s[i++];
	}
	while(j<=high)
	{
		tmp[k++]=s[j++];
	}
	for(i=low,k=0;i<=high;i++)
	{
		s[i]=tmp[k++];
	}
	return 0;

}