基本信息

---

下载

   友情提示：（无需注册或充值，赞助后即可获取资源下载链接）

---

     嘿，亲！知识可是无价之宝呢，但咱这精心整理的资料也耗费了不少心血呀。小小地破费一下，绝对物超所值哦！如有下载和支付问题，请联系我们QQ(微信同号)：813200300

本次赞助数额为： 2 元　

支付宝支付

微信支付

   源码介绍

---

// 调用方法如下：
//
// 1.GetPermutation(T[], startIndex, endIndex)
// 对startIndex到endIndex进行排列，其余元素不变
//
// 2.GetPermutation(T[])
// 返回数组所有元素的全排列
//
// 3.GetPermutation(T[], n)
// 返回数组中n个元素的排列
//
// 4.GetCombination(T[], n)
// 返回数组中n个元素的组合

//-----------------------------------------------------------------------------
//
// 算法：排列组合类
//

//
// 调用方法如下：
//
// 1.GetPermutation(T[], startIndex, endIndex)
// 对startIndex到endIndex进行排列，其余元素不变
//
// 2.GetPermutation(T[])
// 返回数组所有元素的全排列
//
// 3.GetPermutation(T[], n)
// 返回数组中n个元素的排列
//
// 4.GetCombination(T[], n)
// 返回数组中n个元素的组合
//
// 版本历史：
// V0.1 2010-01-20 摘要：首次创建 
//
//-----------------------------------------------------------------------------

using System;
using System.Collections.Generic;

namespace Arithmetic
{
	public class PermutationAndCombination<T>
	{
		#region 内部方法
		/// <summary>
		/// 递归算法求数组的组合(私有成员)
		/// </summary>
		/// <param name="list">返回的范型</param>
		/// <param name="t">所求数组</param>
		/// <param name="n">辅助变量</param>
		/// <param name="m">辅助变量</param>
		/// <param name="b">辅助数组</param>
		/// <param name="M">辅助变量M</param>
		private static void GetCombination(ref List<T[]> list, T[] t, int n, int m, int[] b, int M)
		{
			for (int i = n; i >= m; i--)
			{
				b[m - 1] = i - 1;
				if (m > 1)
				{
					GetCombination(ref list, t, i - 1, m - 1, b, M);
				}
				else
				{
					if (list == null)
					{
						list = new List<T[]>();
					}
					T[] temp = new T[M];
					for (int j = 0; j < b.Length; j  )
					{
						temp[j] = t[b[j]];
					}
					list.Add(temp);
				}
			}
		}

		/// <summary>
		/// 递归算法求排列(私有成员)
		/// </summary>
		/// <param name="list">返回的列表</param>
		/// <param name="t">所求数组</param>
		/// <param name="startIndex">起始标号</param>
		/// <param name="endIndex">结束标号</param>
		private static void GetPermutation(ref List<T[]> list, T[] t, int startIndex, int endIndex)
		{
			if (startIndex == endIndex)
			{
				if (list == null)
				{
					list = new List<T[]>();
				}
				T[] temp = new T[t.Length];
				t.CopyTo(temp, 0);
				list.Add(temp);
			}
			else
			{
				for (int i = startIndex; i <= endIndex; i  )
				{
					Swap(ref t[startIndex], ref t[i]);
					GetPermutation(ref list, t, startIndex   1, endIndex);
					Swap(ref t[startIndex], ref t[i]);
				}
			}
		}
		#endregion

		#region 公共方法
		/// <summary>
		/// 交换两个变量
		/// </summary>
		/// <param name="a">变量1</param>
		/// <param name="b">变量2</param>
		public static void Swap(ref T a, ref T b)
		{
			T temp = a;
			a = b;
			b = temp;
		}

		/// <summary>
		/// 求从起始标号到结束标号的排列，其余元素不变
		/// </summary>
		/// <param name="t">所求数组</param>
		/// <param name="startIndex">起始标号</param>
		/// <param name="endIndex">结束标号</param>
		/// <returns>从起始标号到结束标号排列的范型</returns>
		public static List<T[]> GetPermutation(T[] t, int startIndex, int endIndex)
		{
			if (startIndex < 0 || endIndex > t.Length - 1)
			{
				return null;
			}
			List<T[]> list = new List<T[]>();
			GetPermutation(ref list, t, startIndex, endIndex);
			return list;
		}

		/// <summary>
		/// 返回数组所有元素的全排列
		/// </summary>
		/// <param name="t">所求数组</param>
		/// <returns>全排列的范型</returns>
		public static List<T[]> GetPermutation(T[] t)
		{
			return GetPermutation(t, 0, t.Length - 1);
		}

		/// <summary>
		/// 求数组中n个元素的排列
		/// </summary>
		/// <param name="t">所求数组</param>
		/// <param name="n">元素个数</param>
		/// <returns>数组中n个元素的排列</returns>
		public static List<T[]> GetPermutation(T[] t, int n)
		{
			if (n > t.Length)
			{
				return null;
			}
			List<T[]> list = new List<T[]>();
			List<T[]> c = GetCombination(t, n);
			for (int i = 0; i < c.Count; i  )
			{
				List<T[]> l = new List<T[]>();
				GetPermutation(ref l, c[i], 0, n - 1);
				list.AddRange(l);
			}
			return list;
		}


		/// <summary>
		/// 求数组中n个元素的组合
		/// </summary>
		/// <param name="t">所求数组</param>
		/// <param name="n">元素个数</param>
		/// <returns>数组中n个元素的组合的范型</returns>
		public static List<T[]> GetCombination(T[] t, int n)
		{
			if (t.Length < n)
			{
				return null;
			}
			int[] temp = new int[n];
			List<T[]> list = new List<T[]>();
			GetCombination(ref list, t, t.Length, n, temp, n);
			return list;
		}
		#endregion
	}
}