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

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

菱形分析如下：

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

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

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
}
}