c#中数组array和list在函数间传递 转置

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;

 namespace ConsoleApplication2
 {
     class Program
     {
         static void Main(string[] args)
         {
             double[,] array = new double[, ];
             for (int i = ; i < ; i++)
             {
                 for (int j = ; j < ; j++)
                 {
                     array[i, j] = i + j;
                 }
             }

             //显示原数组
             Console.WriteLine("Source Array:");
             for (int i = ; i < ; i++)
             {
                 string soureResult = string.Empty;
                 for (int j = ; j < ; j++)
                 {
                     soureResult += array[i, j] + "  ";
                 }
                 Console.WriteLine(soureResult);
             }

             double[,] newArray = Rotate(array);
             //显示转置后的数组
             Console.WriteLine("Destiney Array:");
             for (int i = ; i < ; i++)
             {
                 string dstResult = string.Empty;
                 for (int j = ; j < ; j++)
                 {
                     dstResult += newArray[i, j] + "  ";
                 }
                 Console.WriteLine(dstResult);
             }

             Console.ReadLine();
         }

         public static double[,] Rotate(double[,] array)
         {
             int x = array.GetUpperBound(); //一维
             int y = array.GetUpperBound(); //二维
             double[,] newArray = new double[y + , x + ]; //构造转置二维数组
             for (int i = ; i <= x; i++)
             {
                 for (int j = ; j <= y; j++)
                 {
                     newArray[j, i] = array[i, j];
                 }
             }
             return newArray;
         }
     }
 }

二维数组函数间传递及转置

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;

 namespace ConsoleApplication2
 {
     class Program
     {
         /// <summary>
         /// 二维数组转置函数
         /// </summary>
         /// <param name="array"></param>
         /// <returns></returns>
         public static string[,] Rotate(string[,] array)
         {
             int x = array.GetUpperBound(); //一维
             int y = array.GetUpperBound(); //二维
             string[,] newArray = new string[y + , x + ]; //构造转置二维数组
             for (int i = ; i <= x; i++)
             {
                 for (int j = ; j <= y; j++)
                 {
                     newArray[j, i] = array[i, j];
                 }
             }
             return newArray;
         }

         /// <summary>
         /// 将二维列表(List)转换成二维数组，二维数组转置，然后将二维数组转换成列表
         /// </summary>
         /// <param name="original"></param>
         /// <returns></returns>
         public static List<List<string>> Rotate(List<List<string>> original)
         {
             List<string>[] array = original.ToArray();
             List<List<string>> lists = new List<List<string>>();
             if (array.Length == )
             {
                 throw new IndexOutOfRangeException("Index OutOf Range");
             }
             int x = array[].Count;
             int y = original.Count;

             //将列表抓换成数组
             string[,] twoArray = new string[y, x];
             for (int i = ; i < y; i++)
             {
                 int j = ;
                 foreach (string s in array[i])
                 {
                     twoArray[i, j] = s;
                     j++;
                 }
             }

             string[,] newTwoArray = new string[x, y];
             newTwoArray = Rotate(twoArray);//转置

             //二维数组转换成二维List集合
             for (int i = ; i < x; i++)
             {
                 List<string> list = new List<string>();
                 for (int j = ; j < y; j++)
                 {
                     list.Add(newTwoArray[i, j]);
                 }
                 lists.Add(list);
             }
             return lists;
         }

         static void Main(string[] args)
         {
             List<List<string>> sourceList = new List<List<string>>(); //测试的二维List
             for (int i = ; i < ; i++)
             {
                 List<string> list = new List<string>();
                 for (int j = ; j < ; j++)
                 {
                     list.Add(i.ToString() + j.ToString());
                 }
                 sourceList.Add(list);
             }

             //显示原列表
             Console.WriteLine("Source List:");
             for (int i = ; i < sourceList.Count; i++)
             {
                 string soureResult = string.Empty;
                 for (int j = ; j < sourceList[i].Count; j++)
                 {
                     soureResult += sourceList[i][j] + "  ";
                 }
                 Console.WriteLine(soureResult);
             }

             List<List<string>> dstList = Rotate(sourceList);
             //显示转置后的列表
             Console.WriteLine("Destiney List:");
             for (int i = ; i < dstList.Count; i++)
             {
                 string dstResult = string.Empty;
                 for (int j = ; j < dstList[i].Count; j++)
                 {
                     dstResult += dstList[i][j] + "  ";
                 }
                 Console.WriteLine(dstResult);
             }

             Console.ReadLine();
         }
     }
 }

list转置（通过数组中间变量）

---

参考：https://www.cnblogs.com/jeffwongishandsome/archive/2009/11/15/1603130.html

---

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;

 namespace ConsoleApplication2
 {
     class Program
     {
         /// <summary>
         /// 二维数组转置函数
         /// </summary>
         /// <param name="array"></param>
         /// <returns></returns>
         static void Main(string[] args)
         {
             List<List<double>> twolist = new List<List<double>>();
             List<double> onelist = new List<double>();
             onelist.Add(11.0);
             onelist.Add(12.0);
             onelist.Add(13.0);
             twolist.Add(onelist);
             onelist[] = 21.0;//这样会将上面的11也抹去，可见这是地址引用
             onelist[] = 22.0;
             onelist[] = 23.0;
             twolist.Add(onelist);

             //onelist .AddRange (new List<double> {21.0,22.0,23.0});
             //twolist.AddRange(onelist);
             double[,] two = twoDimenListToArray(twolist);

         }
         public static double[,] twoDimenListToArray(List<List<double>> twoDimenList)
         {

             List<double>[] array = twoDimenList.ToArray();//将twoDimenList转换为一维list，list元素为数组
             if (array.Length == )//array这个一维list（元素为数组）有几个数组元素
             {
                 throw new IndexOutOfRangeException("Index OutOf Range");
             }
             int x = array[].Count;//array这个一维list（元素为数组）第一个元素（数组）内有几个元素（double类型数据），相当于列数
             int y = twoDimenList.Count;//二维list中有几个list，相当于行数
             double[,] twoDimenArray = new double[y, x];
             for (int i = ; i < y; i++)//先写行
             {
                 int j = ;
                 foreach (double d in array[i])
                 {
                     twoDimenArray[i, j] = d;
                     j++;
                 }
             }
             return twoDimenArray;
         }

     }
 }

将二维list转换为二维数组

修改：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {
        /// <summary>
        /// 二维数组转置函数
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        static void Main(string[] args)
        {
            List<List<double>> twolist = new List<List<double>>();
            List<double> onelist = new List<double>();
            onelist.Add(11.0);
            onelist.Add(12.0);
            onelist.Add(13.0);
            twolist.Add(onelist);
            List<double> onelist1 = new List<double>();
            onelist1.Add(21.0);//这样会将上面的11也抹去，可见这是地址引用
            onelist1.Add(22.0) ;
            onelist1.Add(23.0);
            twolist.Add(onelist1);

            //onelist .AddRange (new List<double> {21.0,22.0,23.0});
            //twolist.AddRange(onelist);
            double[,] two = twoDimenListToArray(twolist);

        }
        public static double[,] twoDimenListToArray(List<List<double>> twoDimenList)
        {

            List<double>[] array = twoDimenList.ToArray();//将twoDimenList转换为一维list，list元素为数组
            if (array.Length == )//array这个一维list（元素为数组）有几个数组元素
            {
                throw new IndexOutOfRangeException("Index OutOf Range");
            }
            int x = array[].Count;//array这个一维list（元素为数组）第一个元素（数组）内有几个元素（double类型数据），相当于列数
            int y = twoDimenList.Count;//二维list中有几个list，相当于行数
            double[,] twoDimenArray = new double[y, x];
            for (int i = ; i < y; i++)//先写行
            {
                int j = ;
                foreach (double d in array[i])
                {
                    twoDimenArray[i, j] = d;
                    j++;
                }
            }
            return twoDimenArray;
        }

    }
}

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;

 namespace ConsoleApplication2
 {
     class Program
     {
         /// <summary>
         /// 二维数组转置函数
         /// </summary>
         /// <param name="array"></param>
         /// <returns></returns>
         static void Main(string[] args)
         {
             List<List<double>> twolist = new List<List<double>>();
             List<double> onelist = new List<double>();
             onelist.Add(11.0);
             onelist.Add(12.0);
             onelist.Add(13.0);
             twolist.Add(onelist);
             List<double> onelist1 = new List<double>();
             onelist1.Add(21.0);//这样会将上面的11也抹去，可见这是地址引用
             onelist1.Add(22.0) ;
             onelist1.Add(23.0);
             twolist.Add(onelist1);

             //onelist .AddRange (new List<double> {21.0,22.0,23.0});
             //twolist.AddRange(onelist);
             double[,] two = twoDimenListToArray(twolist);
             double[] one=oneDimenListToArray(onelist);

         }
         /// <summary>
         /// 将二维list转换为二维数组
         /// </summary>
         /// <param name="twoDimenList">传入的要转换的二维list列表</param>
         /// <returns>返回转换得到的二维数组</returns>
         public static double[,] twoDimenListToArray(List<List<double>> twoDimenList)
         {

             List<double>[] array = twoDimenList.ToArray();//将twoDimenList转换为一维list，list元素为数组
             if (array.Length == )//array这个一维list（元素为数组）有几个数组元素
             {
                 throw new IndexOutOfRangeException("Index OutOf Range");
             }
             int x = array[].Count;//array这个一维list（元素为数组）第一个元素（数组）内有几个元素（double类型数据），相当于列数
             int y = twoDimenList.Count;//二维list中有几个list，相当于行数
             double[,] twoDimenArray = new double[y, x];
             for (int i = ; i < y; i++)//先写行
             {
                 int j = ;
                 foreach (double d in array[i])
                 {
                     twoDimenArray[i, j] = d;
                     j++;
                 }
             }
             return twoDimenArray;
         }
         /// <summary>
         /// 将一维list转换为一维数组
         /// </summary>
         /// <param name="oneDimenList">传入的要转换的一维list列表</param>
         /// <returns>返回转换得到的一维数组</returns>
         public static double[] oneDimenListToArray(List<double> oneDimenList)
         {
             double[] oneDimenArray = oneDimenList.ToArray();
             return oneDimenArray;
         }

     }
 }

添加一维的转换