分治+全排列+归并+快排

目录

 

分治思想：

       全排列问题：

组合问题：

归并排序：

快速排序：

测试程序：

测试结果：

---

---

---

 

分治思想：

将一个大问题分解成多个小问题，小问题可解，则可以用这几个问题的解构成大问题的解；

分治问题代码模板：

DataType Divide_and_Merage(P)
    {
    if(P<n0)
         Adhoc(P);//问题规模小于一定值则直接解决
    else
        {
        divide P into p1 p1 p3 ...
        for(int i=0;i<=k;i++)
            y[i] =  Divide_and_Merage(pi)
        return Merage(y1,y2,...yn);
        }
    }

全排列问题：

//R = {r1,r2,r3...rn} Ri = R-ri
//当n =1 Perm(R)=r(r1),r1是集合R中唯一元素
//当n>1 Perm(R) 由(r1)Perm(R1) (r2)Perm(R2) (r3)Perm(R3)...组成

void Perm(vector<char>arr, int k, int m,vector<vector<char> >&result)
//递归的产生前缀是arr[0;K-1]后缀是arr[m+1:end],中间全排列的序列
{
	if (k > m)//k>m则说明到达边界，不能再交换了，递归到了最后一个字母，可以输出了
	{
		vector<char>temp;
		for (auto c : arr)
		{
			cout << c;
			temp.push_back(c);
		}
		result.push_back(temp);
		cout << endl;
	}
	else
		for (int i = k; i <= m; i++)
		{
			swap(arr[i], arr[k]);//从第一个（自身）开始交换，a,b...  b,a...
			Perm(arr, k + 1, m, result);//交换后剩余的进行全排列b...开头全排列
			swap(arr[i], arr[k]);//a,b,....换回来，下次和c交换产生c开头全排列
		}
}

void print_2D_vector(vector<vector<char> >&result)
{
	for (auto &row : result)
	{
		for (auto col : row)
			cout << col;
		cout << endl;
	}
}

组合问题：

n个里面取m个，进行组合，temp为缓冲数组，resize预置大小；

//组合问题

void combination(vector<char>&arr, vector<char>&temp, int n, int m, vector<vector<char>>&result)
{
	if (m>0)
	{
		for (int i = n; i >= m; i--)//从后往前先取一个在temp中,然后在剩下的里面取m-1个进行排列
		{
			temp[m - 1] = arr[i - 1];
			//由于确定了当前位置的值
			//则下次递归c(n-1,m-1) 
			combination(arr, temp, i - 1, m - 1, result);
		}
	}
	else
	{
		result.push_back(temp);
	}

}



int main()
{
	vector<char>arr = {'a','b','c','d'};
	vector<char>temp;
	temp.resize(2);
	vector<vector<char>>ret;
	combination(arr, temp, 4, 2,ret);
	for (auto c:ret)
	{
		for (auto t : c)
		{
			cout << t << " ";
		}
		cout << endl;
	}
	return 0;
}

 

归并排序：

将数组不断分裂，直到分裂为单个元素数组后成为n个排序数组，然后对n个排序数据进行不断的合并。（递归实现）

//归并排序
void Merge(int arr[], int left, int mid, int right, int result[])
{
	int i, j, k;
	i = left; j = mid + 1; k = left;
	while (i <= mid&&j <= right)
	{
		if (arr[i] < arr[j])
			result[k++] = arr[i++];
		else
			result[k++] = arr[j++];
	}
	while (i <= mid)
		result[k++] = arr[i++];
	while (j <= right)
		result[k++] = arr[j++];
	for (int i = left; i <= right; i++)
		arr[i] = result[i];
	
}
void MergeSort(int arr[], int left, int right,int result[])
{
	int mid;
	if (left < right) {
		mid = (left + right) / 2;
		MergeSort(arr, left, mid, result);
 		MergeSort(arr, mid + 1, right, result);
		Merge(arr, left, mid, right, result);
	}
}

快速排序：挖坑法，pivot将数组分为两个部分，前部分小于pivot,后部分大于pivot,然后解决前后两个小问题，由于pivot本身在合适的位置，无需合并。

/快速排序：将数组划分为三部分 r[1:q] <q< r[q+1:n]
//对前后子序列进行排序
int partion(int arrey[], int startindex, int endindex)
{
	//取第一个元素作为privot
	int pivot = arrey[startindex];
	int left = startindex;
	int right = endindex;
	int hole_index = startindex;
	while (right > left)
	{
		while (right >= left)
		{
			if (arrey[right] < pivot)//右指针小于pivot
			{
				arrey[hole_index] = arrey[right];//用右指针填坑
				hole_index = right;//坑转移到右指针
				left++;//左指针处的坑被填，左指针加1
				break;
			}
			right--;//若有指针大于pivot则有指针左移
		}

		while (right >= left)
		{
			if (arrey[left] > pivot)
			{
				arrey[hole_index] = arrey[left];
				hole_index = left;
				right--;
				break;
			}
			left++;
		}
	}
	arrey[hole_index] = pivot;//坑的位置填入pivot
	return hole_index;//返回坑的位置
}

void QuickSort(int arr[], int start, int end)
{
	if (start < end) {
		int mid = partion(arr, start, end);
		QuickSort(arr, start, mid - 1);
		QuickSort(arr, mid + 1, end);
	}
}

测试程序：

int main()
{
	vector<char>arr = { 'a','b','c','d'};
	vector<vector<char> >result;
	Perm(arr, 0, arr.size() - 1,result);
	cout << "result that saved is:" << endl;
	print_2D_vector(result);


	int num[]= {3,2,4,5,1,6,7,10,8,9,13,11,12,14};
	int num_sort[7];
	MergeSort(num, 0,6, num_sort);
	QuickSort(num, 7 ,13);
	for (auto c : num)
		cout << c << " ";
	cout << endl;
	return 0;
}

测试结果：