学习笔记整理资料翻出的旧练习，输出实心和空心图形：矩形，三角形，菱形，箭头，心形

基本上没啥好说的，就是有个“双引用控制同一内存区域”。“双引用控制同一内存区域”主要用处就是在输出关于水平线上下对称的图形（如：矩形、菱形等）时，有节省内存的好处。

菱形分析如下：

代码见最后， 这里只抽取输出菱形的关键代码，做分析以表示双引用控制同一内存的问题：

###################################################

Code段

--------------------------------------------------------------

private static char[][] jaggedary；

jaggedary = new char[height][];//假设height = 5

jaggedary[i] = new char[row+i];

jaggedary[height-1-i] = jaggedary[i];

###################################################

Stack段

--------------------------------------------------------------

#2100|    |#2104

#2100| #1100 |#2104

###################################################

Heap段

--------------------------------------------------------------

#1100|     ^    ^    ^    ^    |#1100+(height*4)，根据假设height=5，则末尾地址为1120

#1100|  #4100 ^ #6100 ^ #7100 ^    ^    |#1120

#4100|  空格 ^ 空格 ^  * |#4106

#6100|  空格 ^ * ^  * ^  * |#6108，每个字符2字节

#7100|  空格 ^ * ^  * ^  * ^  * |#7110

#1100|  #4100 ^ #6100 ^ #7100 ^  #6100  ^  #4100  |#1120//双引用控制同一块内存

--------------------------------------------------------------

输出图形的代码，当时的练习，懒得改了，面试经常考图形输出的问题，此处仅提供一个思路

控制台界面代码：

/*
 * 目标: 通过界面和功能的配合, 输出各种图形---此文件实现用户界面控制
 * 作者: R^.^J
 */

using System;
using ShapeFuncNS;//此处通过命名空间来关联用户界面文件和图形功能文件

namespace UserShowNS
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Clear();
            Console.WriteLine("********************************************************");
            Console.WriteLine("*                                                      *");
            Console.WriteLine("*              欢迎使用图形输出小程序!                 *");
            Console.WriteLine("*           Welcome to use this program!               *");
            Console.WriteLine("*                                                      *");
            Console.WriteLine("********************************************************");
            showMenu();//显示输入菜单
        }

        private static void showMenu()
        {
            string userinput;
            bool isloop = true;
            while(isloop)
            {
                Console.WriteLine("-----------------------------------------------------");
                Console.WriteLine("1. 输出矩形\t2. 输出三角形\t3. 输出箭头");
                Console.WriteLine("4. 输出菱形\t5. 输出心形");
                Console.WriteLine();
                Console.WriteLine("0. 退出");
                Console.WriteLine("-----------------------------------------------------");
                Console.Write("请输入您的选择: ");
                userinput = Console.ReadLine().Trim();
                switch (userinput)
                {
                    case "1":
                        inputRectangle();
                        Console.Write("\n");
                        break;
                    case "2":
                        inputTriangle();
                        Console.Write("\n");
                        break;
                    case "3":
                        inputArrow();
                        Console.Write("\n");
                        break;
                    case "4":
                        inputDiamond();
                        Console.Write("\n");
                        break;
                    case "5":
                        inputHeart();
                        Console.Write("\n");
                        break;
                    case "0":
                        isloop = false;
                        Console.WriteLine("感谢您使用本小程序, 再见!");
                        break;
                    default:
                        //nothing to do here!
                        break;
                }
            }
        }

        #region 用户验证
        private static readonly int min = 3;//定义最小值
        private static readonly int max = 30;//定义最大值


        private static bool checkInput(string userinput)
        {
            bool isgood = true;
            char onechar;
            //验证长度
            if (userinput != null && userinput.Length >= min.ToString().Length && userinput.Length <= max.ToString().Length)
            {
                onechar = userinput[0];
                if (onechar >= '1' && onechar <= '9')
                {
                    for (int i = 1; i < userinput.Length; i++)
                    {
                        onechar = userinput[i];
                        if (onechar >= '0' && onechar <= '9')
                        {
                            //nothing to do here!
                        }
                        else//输入不允许的字符
                        {
                            isgood = false;
                            break;
                            //done
                        }
                    }
                    if (isgood == true)
                    {
                        if (Int32.Parse(userinput) >= min && Int32.Parse(userinput) <= max)
                        {
                            //nothing to do here!
                        }
                        else//输入超过允许的范围
                        {
                            isgood = false;
                            //done
                        }
                    }
                    else//输入字符的验证没有通过
                    {
                        //nothing to do here!
                    }
                }
                else//首位为'0'
                {
                    isgood = false;
                    //done
                }
            }
            else//长度挂掉
            {
                isgood = false;
                //done
            }
            return isgood;
        }
        #endregion

        #region 图形输入控制
        private static void inputRectangle()
        {
            string input = null;
            int row = -1;
            int col = -1;

            while (true)
            {
                Console.Write("请输入矩形的行数(" + min.ToString() + "-" + max.ToString() + "): ");
                input = Console.ReadLine().Trim();
                if (checkInput(input))
                {
                    row = Int32.Parse(input);
                    break;
                }
                else
                {
                    //noting to do here!
                }
            }
            while (true)
            {
                Console.Write("请输入矩形的列数(" + min.ToString() + "-" + max.ToString() + "): ");
                input = Console.ReadLine().Trim();
                if (checkInput(input))
                {
                    col = Int32.Parse(input);
                    break;
                }
                else
                {
                    //nothing to do here!
                }
            }
            ShapeFunction.DrawRectangle(row, col);//调用功能函数
        }
        private static void inputTriangle()
        {
            string input = null;
            int row = -1;

            while (true)
            {
                Console.Write("请输入三角形的行数("+min.ToString()+"-"+max.ToString()+"): ");
                input = Console.ReadLine().Trim();
                if (checkInput(input))
                {
                    row = Int32.Parse(input);
                    break;
                }
                else
                {
                    //nothing to do here!
                }
            }
            ShapeFunction.DrawTriangle(row);
        }
        private static void inputArrow()
        {
            string input = null;
            int row = -1;

            while (true)
            {
                Console.Write("请输入箭头的半高行数("+min.ToString()+"-"+max.ToString()+"): ");
                input = Console.ReadLine().Trim();
                if (checkInput(input))
                {
                    row = Int32.Parse(input);
                    break;
                }
                else
                {
                    //nothing to do here!
                }
            }
            ShapeFunction.DrawArrow(row);
        }
        private static void inputDiamond()
        {
            string input = null;
            int row = -1;

            while (true)
            {
                Console.Write("请输入菱形的半高行数("+min.ToString()+"-"+max.ToString()+"): ");
                input = Console.ReadLine().Trim();
                if (checkInput(input))
                {
                    row = Int32.Parse(input);
                    break;
                }
                else
                {
                    //nothing to do here!
                }
            }
            ShapeFunction.DrawDiamond(row);
        }
        private static void inputHeart()
        {
            string input = null;
            int row = -1;

            while (true)
            {
                Console.Write("请输入心形的半高行数("+(min+2).ToString()+"-"+max.ToString()+"): ");
                input = Console.ReadLine().Trim();
                if (checkInput(input))
                {
                    row = Int32.Parse(input);
                    if(row < 5)
                    {
                        //nothing to do here!
                    }
                    else
                    {
                        break;
                    }
                }
                else
                {
                    //nothing to do here!
                }
            }
            ShapeFunction.DrawHeart(row);
        }
        #endregion
    }
}

//思考：
//如何动态的根据用户的输入要求，在控制台中输出：
//矩形
//*********
//*********
//*********
//*********
//三角形
//*
//**
//***
//****
//*****
//******
//箭头
//   *
//*****
//******
//*****
//   *
//
//                *
//                **
//                ***
//                ****
//********************* 
//**********************
//***********************
//**********************
//*********************
//                ****
//                ***
//                **
//                *
//
//箭头分析: 右边的三角形部分占全部长度的1/3(即半高长的3倍), 而箭头的上下三角形的高度之和是半高长的2倍
//
//菱形
//   *
//  ***
// *****
//*******
// *****
//  ***
//   *

//    *
//   ***
//  *****
// *******
//*********
// *******
//  *****
//   ***
//    *
//
//长度为偶数的菱形是不存在的
//
//心形
//
//     ******       ******
//   **********   **********
// ************* *************
//*****************************
//*****************************
//*****************************
// ***************************
//   ***********************
//     *******************
//       ***************
//         ***********
//           *******
//             ***
//              *
//
//    
//       
//            
//               
//                * *                       * *
//            * * * * * *               * * * * * *
//        * * * * * * * * * *       * * * * * * * * * * 
//    * * * * * * * * * * * * *   * * * * * * * * * * * * *
//  * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//  * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//  * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//    * * * * * * * * * * * * * * * * * * * * * * * * * * *
//        * * * * * * * * * * * * * * * * * * * * * * *
//            * * * * * * * * * * * * * * * * * * *
//                * * * * * * * * * * * * * * *
//                    * * * * * * * * * * *
//                        * * * * * * *
//                            * * *
//                              * 
//                    
//                    
//                    
//                          
//                              
//
//row=10(从下到最大行), height是下面的10行, 加上面的9行, 即row-1 +row, 也就是height=2*row-1
//                      width是3倍的row-1, 即width=3*row-1(通过对row的不同情况的比较, 猜出来的) 
//
//
//
//  * *   * *
//* * * * * * *
//* * * * * * *
//* * * * * * *
//  * * * * *
//    * * *
//      *
//
// ** **
//*******
//*******
//*******
// *****
//  ***
//   *
//五行的心形
//
// * *
//*****
//*****
//*****
// ***
//  *
//
//  *   *
//* * * * *
//* * * * *
//* * * * *
//  * * *
//    *
//
//最小的心形是4行, 再小无法成为心形
//
//    *       *
//  * * *   * * *
//* * * * * * * * *
//* * * * * * * * *
//* * * * * * * * *
//  * * * * * * *
//    * * * * *
//      * * *
//        *
//
//
//
// *** ***
//*********
//*********
//*********
// *******
//  *****
//   ***
//    *
//
//
//  *               *
//    *           *   *
//      *       *       *
//        *   *           *
//          *               * 
//        * * *           * * *
//      * * * * *       * * * * *
//    * * * * * * *   * * * * * * *
//  * * * * * * * * * * * * * * * * *
//  * * * * * * * * * * * * * * * * *
//  * * * * * * * * * * * * * * * * *
//    * * * * * * * * * * * * * * *
//      * * * * * * * * * * * * *
//        * * * * * * * * * * *
//          * * * * * * * * * 
//            * * * * * * *
//              * * * * *
//                * * *
//                  *

图形功能代码：

/*
 * 目标: 通过界面和功能的配合输出各种图形---此文件实现图形功能
 */
using System;

namespace ShapeFuncNS
{
    public static class ShapeFunction
    {
        private static readonly int min = 3;//定义最小值
        private static readonly int max = 30;//定义最大值

        private static char[,] twodiary;
        private static char[][] jaggedary;

        public static void DrawRectangle(int row, int col)//外界的提供参数, 必须验证
        {
            if (row >= min && row <= max && col >= min && col <= max)
            {
                fillSolidRectangle(row,col);
                showTwoDiAry();
                Console.Write("\n\n");
                fillHollowRectangle(row,col);
                showTwoDiAry();
            }
            else
            {
                Console.WriteLine("提供的矩形行列值有误!");
            }
        }
        public static void DrawTriangle(int row)
        {
            if (row >= min && row <= max)
            {
                fillSolidTriangle(row);
                showJaggedAry();
                Console.Write("\n\n");
                fillHollowTriangle(row);
                showJaggedAry();
            }
            else
            {
                Console.WriteLine("提供的三角形行数有误!");
            }
        }

        public static void DrawArrow(int row)
        {
            if (row >= min && row <= max)
            {
                fillSolidArrow(row);
                showJaggedAry();
                Console.Write("\n\n");
                fillHollowArrow(row);
                showJaggedAry();
            }
            else
            {
                Console.WriteLine("提供的箭头半高行数有误! ");
            }
        }
        public static void DrawDiamond(int row)
        {
            if (row >= min && row <= max)
            {
                fillSolidDiamond(row);
                showJaggedAry();
                Console.Write("\n\n");
                fillHollowDiamond(row);
                showJaggedAry();
            }
            else
            {
                Console.WriteLine("提供的菱形行数有误! ");
            }
        }
        public static void DrawHeart(int row)
        {
            if(row>= min && row <= max)
            {
                fillSolidHeart(row);
                showJaggedAry();
            }
            else
            {
                Console.WriteLine("提供的心形半高行数有误! ");
            }
        }

        #region 图形填充区
        private static void fillSolidRectangle(int row, int col)//矩形采用二维数组来做
        {
            twodiary = new char[row,col];
            for (int i = 0; i < row; i++)
            {
                for (int j = 0; j < col; j++)
                {
                    twodiary[i, j] = '*';
                }
            }
        }
        private static void fillHollowRectangle(int row, int col)
        {
            twodiary = new char[row, col];
            for (int i = 0; i < row; i++)
            {
                for (int j = 0; j < col; j++)
                {
                    if (i == 0 || i == row - 1)
                    {
                        twodiary[i,j] = '*';
                    }
                    else if (j == 0 || j == col-1)
                    {
                        twodiary[i, j] = '*';
                    }
                    else
                    {
                        twodiary[i, j] = ' ';
                    }
                }
            }
        }

        private static void fillSolidTriangle(int row)//采用交叉数组来做
        {
            jaggedary = new char[row][];
            for (int i = 0; i < row; i++)
            {
                jaggedary[i] = new char[i+1];
                for (int j = 0; j < i + 1; j++)
                {
                    jaggedary[i][j] = '*';
                }
            }
        }
        private static void fillHollowTriangle(int row)
        {
            jaggedary = new char[row][];
            for (int i = 0; i < row; i++)
            {
                jaggedary[i] = new char[i+1];
                for (int j = 0; j < i+1; j++)
                {
                    if (i ==0 || i == row-1)//row-1为最大行号
                    {
                        jaggedary[i][j] = '*';
                    }
                    else if (j == 0 || j == i)
                    {
                        jaggedary[i][j] = '*';
                    }
                    else
                    {
                        jaggedary[i][j] = ' ';
                    }
                }
            }
        }

        private static void fillSolidArrow(int row)
        {
            int height = 2 * row - 1;//row是半高行数, 下半部分是row-1, 总为2*row-1, 或者理解为除了中间行上下对称, 上边多一行, 因此需要-1, 最大行下标height-1
            int arwlen = height + row-1;//row是半高行数, 箭头总长度为3倍的半高长度-1;(从三角形竖切, 左边是正方形, 此处height和row重复包含了最大行与三角形的重复部分, 所以多减去1个星号)
            jaggedary = new char[height][];//等号右边为元素个数, 其最大下标是height-1
            int index = -1;//控制列数的下标, 应为j为局部变量, 很难跨越for语句操作
            for (int i = 0; i < row; i++)
            {
                //Console.WriteLine("插桩桩i="+i);
                if (i == row - 1)//最中间一行, 或者说星号最多的行
                {
                    //Console.WriteLine("插桩桩i=" + i);
                    jaggedary[i] = new char[arwlen];
                    for (int j = 0; j < jaggedary[i].Length; j++)
                    {
                        jaggedary[i][j] = '*';
                    }
                    //Console.WriteLine("插桩桩i=" + i);
                }
                else//去除最中间行, 上下对称
                {
                    jaggedary[i] = new char[height+i];//最上边*号开始的地方, 就是右边三角形的高度
                    jaggedary[height - 1 - i] = jaggedary[i];//除中间行外, 上下对称, 用同一内存区域(图形上半部分的实例)来控制星号的填充
                    //for (int j = 0; j < row - 1 - i; j++)//列处理, row-1为最中间的行号,-i为递减作用, 应为是<row-1-i, 所以实际上是从row-1再-1开始的, 不会存在越界的问题
                    //Console.WriteLine("插桩桩i=" + i);
                    for(index =0;index <height-1;index++)//0到三角形边界的长度是三角形的高度, 即height, 空格数量应该少一个, 即height-1
                    {
                        //if (i < (row - 1)/2)//确定箭头中, 矩形的位置. 此处不适合用row, 应为半高长可能为基数或偶数
                       if (i < (height - 1) / 4+1)//因为height始终为基数, 其-1后能被2或4整除, 适合用来确定矩形位置, 此处再+1, 便会增加空格输出的列数, 可以方便控制箭头矩形部分的高度
                        {
                            //jaggedary[i][j] = ' ';
                            jaggedary[i][index] = ' ';
                        }
                        else
                        {
                            jaggedary[i][index] = '*';
                        }
                        //Console.WriteLine("插桩桩i=" + i+"index="+index);
                    }
                    //for (; j < arwlen; j++)//此处j不设条件, j将会顺次递增, 进而处理包括三角形竖边界在内星号部分
                    for (; index < jaggedary[i].Length;index++ )
                    {
                        //Console.WriteLine("插桩桩i=" + i + "index=" + index);
                        jaggedary[i][index] = '*';
                        //jaggedary[height-1-i][index] = '*';//此句和上面是一样的效果, 通过不同的地址处理同一块内存区域
                    }
                    //Console.WriteLine("插桩桩2i=" + i + "index=" + index);
                }
            }
        }
        private static void fillHollowArrow(int row)
        {
            int height = 2 * row - 1;//row是半高行数, 下半部分是row-1, 总为2*row-1, 或者理解为除了中间行上下对称, 上边多一行, 因此需要-1, 最大行下标height-1
            int arwlen = height + row - 1;//row是半高行数, 箭头总长度为3倍的半高长度-1;(从三角形竖切, 左边是正方形, 此处height和row重复包含了最大行与三角形的重复部分, 所以多减去1个星号)
            jaggedary = new char[height][];//等号右边为元素个数, 其最大下标是height-1
            int index = -1;//控制列数的下标, 应为j为局部变量, 很难跨越for语句操作
            for (int i = 0; i < row; i++)//row为半高, 最高下标为row-1; 只操作一般即可(双引用控制同一块内存)
            {
                //Console.WriteLine("插桩桩i="+i);
                if (i == row - 1)//最中间一行, 或者说星号最多的行
                {
                    //Console.WriteLine("插桩桩i=" + i);
                    jaggedary[i] = new char[arwlen];
                    for (int j = 0; j < jaggedary[i].Length; j++)
                    {
                        if (j ==0 || j == jaggedary[i].Length - 1)
                        {
                            jaggedary[i][j] = '*';
                        }
                        else
                        {
                            jaggedary[i][j] = ' ';
                        }
                        
                    }
                    //Console.WriteLine("插桩桩i=" + i);
                }
                else//去除最中间行, 上下对称
                {
                    jaggedary[i] = new char[height + i];//最上边*号开始的地方, 就是右边三角形的高度
                    jaggedary[height - 1 - i] = jaggedary[i];//除中间行外, 上下对称, 用同一内存区域(图形上半部分的实例)来控制星号的填充
                    //for (int j = 0; j < row - 1 - i; j++)//列处理, row-1为最中间的行号,-i为递减作用, 应为是<row-1-i, 所以实际上是从row-1再-1开始的, 不会存在越界的问题
                    //Console.WriteLine("插桩桩i=" + i);
                    for (index = 0; index < height - 1; index++)//0到三角形边界的长度是三角形的高度, 即height, 空格数量应该少一个, 即height-1
                    {
                        //if (i < (row - 1)/2)//确定箭头中, 矩形的位置. 此处不适合用row, 应为半高长可能为基数或偶数
                        if (i == (height - 1) / 4 +1 )//因为height始终为基数, 其-1后能被2或4整除, 适合用来确定矩形位置, 此处再+1, 便会增加空格输出的列数, 可以方便控制箭头矩形部分的高度
                        {
                            //jaggedary[i][j] = ' ';
                            jaggedary[i][index] = '*';
                        }
                        else
                        {
                            if (i > ((height-1)/4 +1) && index == 0)
                            {
                                jaggedary[i][index] = '*';
                            }
                            else
                            {
                                jaggedary[i][index] = ' ';
                            }
                        }
                        //Console.WriteLine("插桩桩i=" + i+"index="+index);
                    }
                    //for (; j < arwlen; j++)//此处j不设条件, j将会顺次递增, 进而处理包括三角形竖边界在内星号部分
                    for (; index < jaggedary[i].Length; index++)
                    {
                        if (index == height - 1 || index == jaggedary[i].Length - 1)
                        {
                            if(i > (height-1)/4 +1)
                            {
                                if (index == jaggedary[i].Length - 1)
                                {
                                    jaggedary[i][index] = '*';
                                }
                                else
                                {
                                    jaggedary[i][index] = ' ';
                                }
                            }
                            else
                            {
                                jaggedary[i][index] = '*';
                            }
                        }
                        else
                        {
                            //Console.WriteLine("插桩桩i=" + i + "index=" + index);
                            jaggedary[i][index] = ' ';
                            //jaggedary[height-1-i][index] = '*';//此句和上面是一样的效果, 通过不同的地址处理同一块内存区域
                        }
                    }
                    //Console.WriteLine("插桩桩2i=" + i + "index=" + index);
                }
            }
        }

        //菱形的上半部分比下班部分大1, 菱形的行数只能是奇数, 如果限制用户输入奇数, 用户体验较差, 此处改为更通用的输入菱形的半高长度来解决
        private static void fillSolidDiamond(int row)
        {


            #region 初始化过程,交错数组(拼三角形方法)
            ////上三角形和下三角形
            //int height = 2 * row - 1;//row是半高, 那么下半部分应该是row-1, 因此总列数(行数)为2*row -1
            //jaggedary = new char[height][];
            ////实例化交错数组
            //for (int i = 0; i < row; i++)//i从0增长
            //{
            //    jaggedary[i] = new char[i + row];
            //}
            //for (int i = 0; i < row - 1; i++)
            //{
            //    jaggedary[i + row] = new char[height - 1 - i];
            //}
            ////填充数据
            //for (int i = 0; i < jaggedary.Length; i++)
            //{
            //    for (int j = 0; j < jaggedary[i].Length; j++)
            //    {
            //        jaggedary[i][j] = '*';
            //    }
            //    for (int j = 0; j < row - i - 1; j++)
            //    {
            //        jaggedary[i][j] = ' ';
            //    }
            //    for (int j = 0; j < i - row + 1; j++)
            //    {
            //        jaggedary[i][j] = ' ';
            //    }
            //}
            #endregion

            #region 改进的过程
            int height = 2 * row - 1;//row是半高, 那么下半部分应该是row-1, 因此总行数(列数)为2*row-1, 最大行下标height-1
            jaggedary = new char[height][];
            int index = -1;//控制列数的下标, 应为j为局部变量, 很难跨越for语句操作
            for (int i = 0; i < row; i++)//最大行数是row-1, 下半部分的最大行号为row-1-1(上下三角形差1), 此时可以控制所有的行数;
            {
                if (i == row - 1)//星号最多的行, 除去该行, 上下行数相同
                {
                    jaggedary[i] = new char[height];
                    for (int j = 0; j<jaggedary[i].Length; j++)
                    {
                        jaggedary[i][j] = '*';
                    }
                }
                else//除去星号最多行的, 对称的三角形部分
                {
                    jaggedary[i] = new char[row +i];//等号右边表示元素个数, 比下标要大1. 列数长度从row(下标为row-1)递增
                    //jaggedary[height-1-i] = new char[row +i];//新实例化下边的三角形
                    jaggedary[height - 1 - i] = jaggedary[i];//第i(下标)行与第height-1-i行指向同一个内存地址(堆中), 因为他们要创建的一维数组长度相同, 所以公用同一实例
                    for (index = 0; index < row -1 - i; index++)//在第i行, 大于0小与row-1-i的位置, 输出空格, 不算最大行
                    {
                        jaggedary[i][index] = ' ';
                    }
                    for (; index < jaggedary[i].Length; index++)//在同一个i行, 大于row-i小于数组长度的位置, 输入*
                    {
                        jaggedary[height - 1 - i][index] = '*';//王老师故意写成此样
                        //jaggedary[i][index] = '*';//此句和上面是一样的效果, 通过不同的地址处理同一块内存区域
                    }
                }

            }
            #endregion
        }
        private static void fillHollowDiamond(int row)
        {


            #region 改进的过程
            int height = 2 * row - 1;//row是半高, 那么下半部分应该是row-1, 因此总行数(列数)为2*row-1
            jaggedary = new char[height][];
            int index = -1;//列下标
            for (int i = 0; i < row; i++)//控制行号
            {
                if (i == row - 1)//最大行
                {
                    jaggedary[i] = new char[height];
                    for (int j = 0; j < jaggedary[i].Length; j++)
                    {
                        if (j == 0 || j == jaggedary[i].Length - 1)
                        {
                            jaggedary[i][j] = '*';
                        }
                        else
                        {
                            jaggedary[i][j] = ' ';
                        }
                    }
                }
                else
                {
                    jaggedary[i] = new char[row+i];//一位数组的长度
                    //jaggedary[height - 1 - i] = new char[row + i];//新创建了下三角形的实例
                    jaggedary[height - 1 - i] = jaggedary[i];//直接将正数第i行一维数组的地址给倒数第i行, 公用同一内存地址(一维数组), 或者说双引用地址控制同一块内存地址(一维数组)
                    for (index = 0; index < row-1-i; index++)
                    {
                        jaggedary[i][index] = ' ';
                    }
                    for (; index < jaggedary[i].Length; index++)
                    {
                        if (index == row -1 - i || index == jaggedary[i].Length - 1)
                        {
                            jaggedary[i][index] = '*';
                        }
                        else
                        {
                            jaggedary[i][index] = ' ';
                        }
                    }
                }
            }
            #endregion
        }

        //心形是建立在菱形的基础之上的, 同样上半部分比下班部分大1, 心形的行数只能是奇数, 如果限制用户输入奇数, 用户体验较差, 此处改为更通用的输入菱形的半高长度来解决
        private static void fillSolidHeart(int row)
        {
            int height = 2*row-1;//height可以做菱形的高度, 也可以做菱形的宽度, 为2*row-1. 但中间相同长度的3行, 可以通过删除最中间行的上一行和下一行的首位星号来实现
            int heartheight = (height-1)/2 ;//用于控制列数心形上半部分中曲线位置的高度, height为基数, -1除2为偶数
            jaggedary = new char[height][];
            for (int i = 0; i < height; i++)
            {
                if (i == row - 1)//最中间一行
                {
                    jaggedary[i] = new char[height];
                    for (int j = 1; j < jaggedary[i].Length-1; j++)
                    {
                        jaggedary[i][j] = '*';
                    }
                    //Console.WriteLine("插桩桩!i=" + i+"j="+j);
                }
                else if(i < row -1)//中间以上
                {
                    //Console.WriteLine("插桩桩!i=" + i);
                    jaggedary[i] = new char[row + i];
                    jaggedary[height - 1 - i] = new char[row + i];//与上面语句一起, 同时实例化
                    //jaggedary[height - 1 - i] = jaggedary[i];//双引用控制同一块内存, 该写法会让图形上下对称, 而心形不是上下对称的, 所以只能实例化是只能是上一种写法, 这种写法可实现菱形的输出, 但是心形是不可以的

                    if (i < heartheight -1 )//中间三行中, 最上边一行以上的部分, 即除中间行和上半部分的三角形底边的三角形部分
                    {
                        if (i > heartheight / 2)//心形被截取后的下半部分到上三角形底边之间的部分
                        {
                            for (int j = 0; j < row - 1 - i; j++)//上三角形考左边的空格三角形部分
                            {
                                jaggedary[i][j] = ' ';
                            }
                            for (int j = row - 1 - i; j < jaggedary[i].Length; j++)//上三角形中, 除去空格三角形的菱形部分, 是个顶点在中间的三角形(即菱形的上半部分)
                            {
                                jaggedary[i][j] = '*';
                            }
                            for (int j = i + 2; j < row; j++)//菱形的上三角形中, 中空部分的左半个, 即心形中间的倒三角形中的左半边
                            {
                                jaggedary[i][j] = ' ';
                            }
                            if (i <= heartheight / 2 - 1)//菱形的上三角形中, 中空部分的右半边的上部分, 即心形中间的倒三角形中的右半边的上部分
                            {
                                for (int j = row - 1; j < jaggedary[i].Length; j++)
                                {
                                    jaggedary[i][j] = ' ';
                                }
                            }
                            else if (i < row - 1 - 1)//在除中间行的上三角形中, 底边以上的部分
                            {
                                //Console.WriteLine("i1=" + i + "j1=");
                                for (int j = 0; j < row - 2 - i; j++)//心形中间的倒三角形中的右半边的下部分(row-i-2), 这里是由大量数据对比所得, 费了好些时间, 最后得出3,2,1的递减结果
                                {
                                    //Console.WriteLine("i="+i+"j="+j);
                                    jaggedary[i][row - 1 + j] = ' ';//row-1的位置, +3, +2, +1后,得到中间倒三角形中的右半边的下部分, 此处较花费时间
                                }
                            }
                        }
                        else//截取心形的上班部分的一半, 去掉三角形的尖
                        {
                            for (int j = 0; j < jaggedary[i].Length; j++)
                            {
                                jaggedary[i][j] = ' ';
                            }
                        }
                    }
                    else//除去最中间行的上半部分三角形的底边, 即和最中间行相同的条
                    {
                        for (int j = row-i-1; j < jaggedary[i].Length; j++)
                        {
                            jaggedary[i][j] = '*';
                        }
                    }
                }
                else//中间以下
                {
                    for (int j = 0; j < i - row+1; j++)//控制下半部分的靠左边的三角形, 也作(r-(row-1))
                    {
                        //Console.WriteLine("i="+i+"j="+j);
                        jaggedary[i][j] = ' ';
                    }
                    for (int j = i - row +1; j < jaggedary[i].Length; j++)//下半部分的倒三角部分
                    {
                        jaggedary[i][j] = '*';
                    }
                    jaggedary[i][row - 1] = '*';
                }
            }
        }
        #endregion

        #region 图形显示区
        private static void showTwoDiAry()
        {
            for (int i = 0; i < twodiary.GetLength(0); i++)//二维数组的第一个维(0号维), 就是一维数组的个数
            {
                for (int j = 0; j < twodiary.GetLength(1); j++)//二维数组的第二个维(1号维), 就是一维数组元素的个数
                {
                    Console.Write(twodiary[i,j].ToString());
                    Console.Write(" ");
                }
                Console.Write("\n");
            }
        }

        private static void showJaggedAry()
        {
            for (int i = 0; i < jaggedary.Length; i++)
            {
                for (int j = 0; j < jaggedary[i].Length; j++)
                {
                    Console.Write(jaggedary[i][j].ToString());
                    Console.Write(" ");
                }
                Console.Write("\n");
            }
        }
        #endregion
    }
}