算法：分治策略3

---

一、

1.最接近点对（平面）

#include<iostream>
#include<list>
#include<vector>
#include<queue>
#include<stack>
#include<stdio.h>
#include<algorithm>
#include<limits.h>
using namespace std;

typedef int ElemType;
typedef struct ListNode
{
	ElemType data;
	struct ListNode* next;
}ListNode, * LinkList;

ListNode* ListQuickParition(ListNode* left, ListNode* right)
{
	ListNode* i = left->next;
	ListNode* j = left;
	int tmp = i->data;
	while (i != right)
	{
		if (i->data <= tmp)
		{
			j = j->next;
			swap(j->data, i->data);
		}
		i = i->next;
	}
	swap(left->next->data, i->data);

	ListQuickParition(left, i);
	ListQuickParition(i, right);
}
void Print_Ar(const int* br, int n)
{
	if (br == NULL || n < 1) return;
	for (int i = 0; i < n; ++i)
	{
		cout << br[i] << " ";
	}
	cout << endl;
}
int Parition(int* br, int left, int right)
{
	int tmp = br[left];
	while (left < right)
	{
		while (left < right && br[right]>tmp)
		{
			--right;
		}
		if (left < right)
		{
			br[left] = br[right];
		}
		while (left < right && br[left] <= tmp)
		{
			++left;
		}
		if (left < right)
		{
			br[right] = br[left];
		}
	}
	br[left] = tmp;
	return left;
}
void PassQuick(int* br, int left, int right)
{
	if (left < right)
	{
		int pos = Parition(br, left, right);
		PassQuick(br, left, pos - 1);
		PassQuick(br, pos + 1, right);
	}
}
void QuickSort(int* br, int n)//非递归排序算法
{
	if (br == NULL || n < 2) return;
	queue<int> qu;
	qu.push(0);
	qu.push(n - 1);
	while (!qu.empty())
	{
		int left = qu.front();
		qu.pop();
		int right = qu.front();
		qu.pop();
		int pos = Parition(br, left, right);
		if (left < pos - 1)
		{
			qu.push(left);
			qu.push(pos - 1);
		}
		if (pos + 1 < right)
		{
			qu.push(pos + 1);
			qu.push(right);
		}
	}
}
void QuickSort(int* br, int n)//递归排序算法
{
	if (br == NULL || n < 2) return;
	PassQuick(br, 0, n - 1);
}
void QuickSort(int* br, int n)//队排序算法(第一种)
{
	if (br == NULL || n < 2) return;
	queue<std::pair<int, int>> qu;
	qu.push(std::pair<int, int>(0, n - 1));//左边和右边
	while (!qu.empty())
	{
		std::pair<int, int> pos = qu.front();
		qu.pop();
		int mid = Parition(br, pos.first, pos.second);
		if (pos.first < mid - 1)
		{
			qu.push(std::pair<int, int>(pos.first, mid - 1));
		}
		if (mid + 1 < pos.second)
		{
			qu.push(std::pair<int, int>(mid + 1, pos.second));
		}
	}
}
int Parition(int* br, int left, int right)//双向划分
{
	int tmp = br[left];
	while (left < right)
	{
		while (left<right && br[right]>tmp)
		{
			--right;
		}
		if (left < right)
		{
			br[left] = br[right];
		}
		while (left < right && br[left <= tmp])
		{
			++left;
		}
		if (left < right)
		{
			br[right] = br[left];
		}
	}
	br[left] = tmp;
	return left;
}
int LeftParition(int* br, int left, int right)//单向划分
{
	int j = left - 1;
	int i = left;
	int tmp = br[i];
	while (i <= right)
	{
		if (br[i] <= tmp)
		{
			j = j + 1;
			swap(br[j], br[i]);
		}
		++i;
	}
	swap(br[left], br[j]);
	return j;
}
int RandParition(int* br, int left, int right)//随机法划分
{
	srand(time(NULL));
	int pos = rand() % (right - left);
	std::swap(br[left], br[pos]);
	return Parition(br, left, right);
}
int MidParition(int* br, int left, int right)//三位取中法划分
{
	int mid = (right - left) / 2 + left;
	struct IndexNode
	{
		int key;
		int index;

		operator int() const//强转
		{
			return key;
		}
	};
	struct IndexNode kL = { br[left],left };
	struct IndexNode kM = { br[mid],mid };
	struct IndexNode kR = { br[right],right };

	std::priority_queue<IndexNode> hp;
	hp.push(kL);
	hp.push(kM);
	hp.push(kR);
	hp.pop();
	struct IndexNode pos = hp.top();

	std::swap(br[kL.index], br[pos.index]);
	return Parition(br, left, right);
}
void QuickSort(int* br, int n)//队排序算法(第二种)
{
	if (br == NULL || n < 2) return;
	typedef std::pair<int, int> Pair;//typedef关键使程序更加清楚
	queue<Pair> qu;
	qu.push(Pair(0, n - 1));
	while (!qu.empty())
	{
		Pair pos = qu.front();
		qu.pop();
		int mid = Parition(br, pos.first, pos.second);
		if (pos.first < mid - 1)
		{
			qu.push(Pair(pos.first, mid - 1));
		}
		if (mid + 1 < pos.second)
		{
			qu.push(Pair(mid + 1, pos.second));
		}
	}
}
int FindK(int* br, int left, int right, int k)
{
	if (left == right && k == 1)
	{
		return br[left];
	}
	int pos = Parition(br, left, right);
	int j = pos - left + 1;
	if (k <= j)
	{
		return FindK(br, left, pos, k);
	}
	else
	{
		return FindK(br, pos + 1, right, k - j);
	}
}
int FindK_Min(int* br, int n, int k)//寻找第k小的元素
{
	if (br == NULL || k<0 || k>n)
	{
		return INT_MAX;//头文件 #include<limits.h>
	}
	return FindK(br, 0, n - 1, k);
}
int MaxS1(const int* br, int left, int right)//寻找最大值
{
	return br[right];
}
int MinS2(const int* br, int left, int right)//寻找最小值
{
	int mins = br[left];
	for (int i = left + 1; i <= right; ++i)
	{
		if (mins > br[i])
		{
			mins = br[i];
		}
	}
	return mins;
}
int Min(int a, int b)
{
	return a < b ? a : b;
}
int Min(int a, int b, int c)
{
	return Min(a, Min(b, c));
}
int Cpair(int* br, int left, int right)
{
	if ((right - left) <= 0)
	{
		return INT_MAX;
	}
	int mid = (right - left) / 2;//逻辑中间值
	FindK(br, left, right, mid);
	int pos = mid + left - 1;;//物理中间值

	int d1 = Cpair(br, left, pos);
	int d2 = Cpair(br, pos + 1, right);

	int maxs = MaxS1(br, left, pos);
	int mins = MinS2(br, pos + 1, right);

	return Min(d1, d2, mins - maxs);
}
int Cpair_Ar(int* br, int n)
{
	if (br == NULL || n < 2)
	{
		return INT_MAX;
	}
	else
	{
		return Cpair(br, 0, n - 1);
	}
}
int main()
{
	int ar[] = { 56,12,78,90,34,23,100,56,45,67,89 };
	int n = sizeof(ar) / sizeof(ar[0]);
	int dist = Cpair_Ar(ar, n);

	cout << dist << endl;
	return 0;
}
void Copy(int* src, int* dest, int left, int right)
{
	while (left <= right)
	{
		dest[left] = src[left];
		left++;
	}
}
void Merge(int* src, int* dest, int left, int m, int right)//合并排序
{
	int i = left, j = m + 1;
	int k = left;
	while (i <= m && j <= right)
	{
		dest[k++] = src[i] <= src[j] ? src[i++] : src[j];
	}
	while (i <= m)
	{
		dest[k++] = src[i++];
	}
	while (j <= right)
	{
		dest[k++] = src[j++];
	}
}
void MergePass(int* src, int* dest, int left, int right)
{
	if (left < right)
	{
		int mid = (right + left) / 2;
		MergePass(src, dest, left, mid);
		MergePass(src, dest, mid + 1, right);

		Merge(src, dest, left, mid, right);
		Copy(dest, src, left, right);
	}
}
void MergeSort(int* br, int n)
{
	if (br == NULL || n < 2)
	{
		return;
	}
	int* tmp = new int[n];
	MergePass(br, tmp, 0, n - 1);
	delete[]tmp;
}

2.归并排序算法

void Merge(int* src, int* dest, int left, int m, int right)//合并排序
{
	int i = left, j = m + 1;
	int k = left;
	while (i <= m && j <= right)
	{
		dest[k++] = src[i] <= src[j] ? src[i++] : src[j];
	}
	while (i <= m)
	{
		dest[k++] = src[i++];
	}
	while (j <= right)
	{
		dest[k++] = src[j++];
	}
}
void MergePass(int* src, int* dest, int left, int right)
{
	if (left < right)
	{
		int mid = (right + left) / 2;
		MergePass(src, dest, left, mid);
		MergePass(src, dest, mid + 1, right);

		Merge(src, dest, left, mid, right);
		Copy(dest, src, left, right);
	}
}
void MergeSort(int* br, int n)//递归写法
{
	if (br == NULL || n < 2)
	{
		return;
	}
	int* tmp = new int[n];//动态开辟空间
	MergePass(br, tmp, 0, n - 1);
	delete[]tmp;
}


void MergeSort(int* br, int n)//非递归写法
{
	if (br == NULL || n < 2)
	{
		return;
	}
	int* tmp = new int[n];//动态开辟空间
	int s = 1;
	while (s < n)
	{
		MergePass(br, tmp, n, s);
		s += s;
		MergePass(tmp, br, n, s);
		s += s;
	}
	delete[]tmp;
}
void MergePass(int* src, int* dest, int n, int s)//非递归写法
{
	int i = 0;//n代表总个数
	for (i = 0; i + 2 * s - 1 <= n - 1; i = i + 2 * s)
	{
		Merge(src, dest, i, i + s - 1, i + 2 * s - 1);
	}
	if (n-1>s+s-1)
	{
		Merge(src, dest, i, i + s - 1, n - 1);
	}
	else
	{
		for (int j = i; j < n; ++j)
		{
			dest[j] = src[j];
		}
	}
}

3.other

n路归并算法（难）

二、排列算法

1.全排列树

void Perm(int* br, int i, int m)
{
	if (i == m)
	{
		for (int j = 0; i <= m; ++j)
		{
			cout << br[j] << " ";
		}
		cout << endl;
	}
	else
	{
		for (int j = i; j <= m; ++j)
		{
			std::swap(br[i], br[j]);
			Perm(br, i + 1, m);//每次递归时候规模缩小
			std::swap(br[i], br[j]);
		}
		
	}
}

2.子集树

void Print(int* ar, int* br, int i, int n)
{
	if (i >= n)
	{
		for (int j = 0; j < n; ++j)
		{
			if (br[j] == 1)
			{
				cout << ar[j] << " ";
			}
		}
		cout << endl;
	}
	else
	{
		br[i] = 1;
		Print(ar, br, i + 1, n);
		br[i] = 0;
		Print(ar, br, i + 1, n);
	}
}

---