从数组中返回指定长度的子数组[转]

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

namespace ConsoleApplication3
{
    class Program
    {
        static void Main(string[] args)
        {
            //要操作的源数组
            List<int> originalArray = new List<int>();
            for (int i = 1; i <= 10; i++)
            {
                originalArray.Add(i);
            }
            Console.Write("源数组：");
            foreach (int item in originalArray)
            {
                Console.Write(item + " ");
            }
            Console.WriteLine();
            //得到指定长度的子数组
            List<List<int>> resultArray = SubChildArray(originalArray, originalArray.Count - 1);

            for (int i = 0; i < resultArray.Count; i++)
            {
                Console.Write("子数组" + (i + 1) + "：");
                for (int j = 0; j < resultArray[i].Count; j++)
                {
                    Console.Write(resultArray[i][j] + " ");
                }
                Console.WriteLine();
            }

            Console.WriteLine("子数组的数量:" + resultArray.Count);
            Console.ReadKey();
        }
        /// <summary>
        /// 得到指定长度的子数组
        /// </summary>
        /// <param name="originalArray">源数组</param>
        /// <param name="arrayLength">要取出子数组的长度</param>
        /// <returns></returns>
        static List<List<int>> SubChildArray(List<int> originalArray, int arrayLength)
        {
            List<List<int>> result = new List<List<int>>();
            List<int> one = new List<int>();

            for (int i = 0; i < originalArray.Count; i++)
            {
                one.Add(originalArray[i]);
                Add(originalArray.GetRange(i + 1, originalArray.Count - 1 - i), arrayLength - 1, result, one);
                if (one.Count != 0)
                    one.RemoveAt(one.Count - 1);
                //这里很可以用one.Clear();
                //循环完一次后，就可以清除one，然后再重新开始
            }
            return result;
        }
        /// <summary>
        /// 用于递归的函数
        /// </summary>
        /// <param name="array"></param>
        /// <param name="n"></param>
        /// <param name="result"></param>
        /// <param name="one"></param>
        static void Add(List<int> array, int n, List<List<int>> result, List<int> one)
        {
            //如果n=0，就表明one的Count属性已等于n
            if (n == 0)
            {
                result.Add(Clone(one) as List<int>);
                //进行下一次之前，移除最后一个元素
                one.RemoveAt(one.Count - 1);
            }
            else
            {
                for (int i = 0; i < array.Count; i++)
                {
                    one.Add(array[i]);
                    //在这里进行递归，同时n-1
                    Add(array.GetRange(i + 1, array.Count - 1 - i), n - 1, result, one);
                }
                //一轮结束后，移除最后一个元素
                one.RemoveAt(one.Count - 1);
            }
        }
        /// <summary>
        /// 用来复制对象的函数
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static object Clone(object obj)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                IFormatter formattor = new BinaryFormatter();
                formattor.Serialize(ms, obj);
                ms.Seek(0, SeekOrigin.Begin);
                return formattor.Deserialize(ms);
            }
        }
    }
}

 转自：http://www.cnblogs.com/xiangism/archive/2009/09/06/1561398.html