C#学习Day06

最新推荐文章于 2024-07-12 14:17:28 发布

万年份的单身汉

最新推荐文章于 2024-07-12 14:17:28 发布

阅读量343

点赞数 4

文章标签：学习 c#

本文链接：https://blog.csdn.net/ycb1746147428/article/details/140180109

版权

1.整数转换，整数和字符串，字符串和整数之间的转换怎么实现？

string str = "123456";

int a = 123456;

Console.WriteLine("字符串类型验证{0}",(str+666));//123456666

Console.WriteLine("整型类型验证{0}",(a+666));//124122

//整型会执行计算，而字符串类型不计算而是连接成新的字符串

int stri1=int.Parse(str);

int stri2=Convert.ToInt32(str);

//字符串转整型,Convert方法还可以根据需求进行多样的转换

Console.WriteLine("整型转换验证：{0}",(stri1+stri2));//246912

string astr1 = a + "666";

string astr2 = Convert.ToString(a);

//整型转字符型，任意整型加字符串即可转为字符串

Console.WriteLine("字符串型转换验证：{0}",(astr1+astr2));

//123456666123456

2.日期转换，获取当前日期，字符串转日期，日期转字符串怎么实现？

DateTime dt = DateTime.Now;//获取当前日期

DateTime dt1=new DateTime(2009,01,01,12,08,05);//手动赋值日期

Console.WriteLine(dt);//在c#中日期对象dt会自动调用Tostring()来正确的输出

Console.WriteLine(dt1.ToString());

Console.WriteLine(dt.Year);//C#中还可以单独提取某一日期信息进行操作,年月日时分秒

Console.WriteLine(dt.Month);

Console.WriteLine(dt.Day);

string s = "2012-12-12";

DateTime dt2 = DateTime.Parse(s);//字符串转日期函数同样可以用Paese

Console.WriteLine(dt2.ToString());//2012-12-12 0:00:00 未填默认为0

3.举例一维、二维、三维数组

在实际内存存储中是不分维数的，所有数据线性的存储在内存中，但是为了编程方便，我们将数组按需求分为几种常见的数组：

int[] a= new int[2];//声明一个可存两个值的一维数组,未初始化默认值为0

//for循环遍历整个数组

Console.WriteLine("不含初始化声明的一维数组");

for (int i = 0;i<a.Length;i++)//a.Length获取数组长度

{

    Console.WriteLine("未赋值前a[{0}]：{1}",i,a[i]);

    a[i] = 666+i;

    Console.WriteLine("赋值后a[{0}]：{1}",i,a[i]+" ");

}

Console.WriteLine();

int[] a1 = new int[2] { 666, 888 };//含有初始化的声明

int[] a2 = { 777, 999, 111 };//省略部分代码的初始化

Console.WriteLine("含初始化声明的一维数组");

foreach (int i in a1)//foreach遍历数组

{

    Console.Write(i+" ");

}

Console.WriteLine();

foreach (int i in a2)

{

    Console.Write(i+" ");

}

Console.WriteLine();

Console.WriteLine();

int[,] b = new int[2, 3] {//二维数组就是几个一维数组相接

{1,2,3},

{4,5,6}

};

Console.WriteLine("二维数组遍历");

//遍历二维数组时，需要分别对两个维度长度进行获取GetLenth(n),维度数同样由0开始

for (int i = 0; i<b.GetLength(0);i++)

{

    for (int j = 0; j < b.GetLength(1);j++)

    {

        Console.Write(b[i,j] + " ");

    }

    Console.WriteLine();

}

Console.WriteLine();

Console.WriteLine();

int[,,] c = new int[2, 2, 3] { //三维数组同理是几个二维数组相接，后续更高维的数组也是同理往上推，但一般都需要降维成一二三来进行处理

    {{ 1,2,2},{ 3,4,3} },

    {{ 5,6,5},{ 7,8,7} }

};

Console.WriteLine("三维数组遍历");

for (int i = 0;i<c.GetLength(0);i++)

{

    for(int j = 0;  j<c.GetLength(1);j++)

    {

        for(int k = 0; k<c.GetLength(2);k++)

        {

            Console.Write(c[i,j,k]+" ");

        }

        Console.WriteLine();

    }

    Console.WriteLine();

}

4.需求：有个88笔费用的记录，总额3亿，金额在300万~800万之间，随机数如何实现？并记录总耗时。

RandomAmount.cs

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

namespace DJConsoleProject
{
    public class RandomAmount
    {
        public long Romamount(int rcount,int min,int max,long cur,long Totalam,int i)
        {
            Random random = new Random();
            long amount;
            while (true)
            {
                amount = random.Next(min / 1000, max / 1000 + 1) * 1000;
                if (cur+amount < Totalam - (rcount - i - 1) * min) 
                { return amount; }
            }
            
        }
    }
}

Program.cs

using DJConsoleProject;
using System.Diagnostics;

const int RecordCount = 88;
const long TotalAmount = 300000000;
const int MinAmount = 3000000;
const int MaxAmount = 8000000;

RandomAmount rm = new RandomAmount();

DateTime dateTimestart = DateTime.Now;//计时器开始
long[] expenses= new long[RecordCount];//记录88条费用
long current= 0;//当前总费用
for (int i=0; i<RecordCount; i++)
{
    long amount=rm.Romamount(RecordCount, MinAmount, MaxAmount,current, TotalAmount,i);
    expenses[i]= amount;
    current+=amount;
}
expenses[RecordCount - 1] += (TotalAmount - current);//为保证最终总费用为指定数目，对最后一个值重新赋值
DateTime dateTimeend = DateTime.Now;//计时器结束
TimeSpan duration = dateTimeend - dateTimestart;
Console.WriteLine("费用分别为：");
int tmp = 1;
foreach (var i in expenses)
{
    Console.WriteLine("第{0}条费用为：{1}",tmp,i);
    tmp++;
}

Console.WriteLine("总费用是："+expenses.Sum());
Console.WriteLine("总共用时：" + duration.TotalMilliseconds+"ms");

测试结果如下：

5.简述常见的集合类型的存储结构和它们的作用以及优缺点，并写出实现案例

1）数组Array

存储结构：数组是固定大小的线性数据结构，存储在连续的内存块中。

作用：用于存储相同类型的元素，可以通过索引快速访问元素。

优点：通过索引快速访问。简单快捷

缺点：大小固定，灵活性低。插入删除操作效率低。

案例详见本文题1；

2）列表List<T>（ArrayList）

存储结构：基于数组的动态数组，大小可以根据需求动态调整。

作用：用于存储相同类型的元素，提供动态大小和便捷的插入、删除操作。

优点：动态调整大小。插入和删除操作相对高效。

缺点：随机访问性能略差于数组。

示例代码：

using System.Collections;

ArrayList arrayList = new ArrayList();

arrayList.Add(1);

arrayList.Add(2);

arrayList.Add(3);

arrayList.Add(4);

arrayList.Add("5");//动态数组ArrayList具有一定容错性，但同时具有安全隐患

arrayList.Remove(6);//具有容错性，不会报错

Console.WriteLine("arrayList实际元素数量："+arrayList.Count);

Console.WriteLine("动态申请的内存数量："+arrayList.Capacity);//申请时翻倍申请，一定是2的倍数

Console.WriteLine("输出动态数组arrayList内容");

foreach (var i in arrayList)

{

    Console.Write(i+" ");

}

Console.WriteLine();

List<int> list = new List<int>();//动态数组List,<>泛型，编译器编译时可进行类型检查

list.Add(10);

list.Add(20);

list.Add(30);

list.Add(40);

//list.Add("666"); 这里规定只能存int类型，否则报错, 提升安全性

list.Add(50);

Console.WriteLine("List实际元素数量：" + list.Count);

Console.WriteLine("动态申请的内存数量：" + list.Capacity);

Console.WriteLine("输出动态数组List内容");

foreach (var i in list)

{

    Console.Write(i + " ");

}

3)链表LinkedList<T>

存储结构：双向链表，每个节点包含一个数据元素和两个指针，分别指向前一个和后一个节点。

作用：用于频繁插入和删除操作的场景，可以在任意位置高效插入和删除元素。

优点：插入和删除操作在已知位置时非常高效。可以高效在头部和尾部进行操作。

缺点：随机访问性能差，需要从头部或尾部遍历。相对于数组内存开销大。

示例代码：

LinkedList<string> linkedList = new LinkedList<string>();

linkedList.AddFirst("张三");//从表头插入

linkedList.AddFirst("李四");//成为新的表头

linkedList.AddLast("王五");//从表尾插入

linkedList.Remove("赵六");//具有容错性

var node = linkedList.Find("王五");

Console.WriteLine("当前节点的值："+node.Value);

Console.WriteLine("输出链表");//李四，张三，王五

foreach (var item in linkedList)

{

    Console.WriteLine(item," ");

}

4）栈Stack<T>

存储结构：基于链表或数组的LIFO（后进先出）结构。

作用：用于逆序处理元素，后进先出

优点：高效的入栈和出栈操作。保持元素的处理顺序。

缺点：随机访问性能差。

示例代码：

Stack<int> stack= new Stack<int>();

stack.Push(0);//进栈

stack.Push(1);

stack.Push(2);

stack.Push(3);

Console.WriteLine("按后进先出原则依次出栈");

while (stack.Count > 0)

{

    Console.WriteLine(stack.Pop());

}

5）队列Queue<T>

存储结构：基于链表或数组的FIFO（先进先出）结构。

作用：用于按顺序处理元素，先进先出的数据结构。

优点：高效的入队和出队操作。保持元素的处理顺序。

缺点：随机访问性能差。

示例代码：

Queue<int> queue = new Queue<int>();

queue.Enqueue(1);

queue.Enqueue(2);

queue.Enqueue(3);

queue.Enqueue(4);

Console.WriteLine("按先进先出原则依次出队");

while (queue.Count > 0)

{

    Console.WriteLine(queue.Dequeue());

}

6）哈希表Hashtable

存储结构：基于哈希函数，将键映射到存储桶（bucket）中，每个桶包含一个链表，用于处理哈希冲突。

作用：用于键值对的存储和快速查找，通过键来访问值。

优点：快速查找、插入和删除操作。

缺点：内存开销较大。

示例代码：

using System.Collections;

Hashtable hashtable = new Hashtable();

hashtable["one"] = 1;//添加键值对

hashtable["two"] = 2;

hashtable["three"] = 3;

hashtable["four"] = 4;

hashtable.Remove("five");//具有容错性，不会报错

Console.WriteLine("输出哈希表值");

foreach (DictionaryEntry enty in hashtable )//调用字典（也是基于哈希的一种键值对结构）输出哈希表的键值对

{

    Console.WriteLine("键：{0}：值：{1}",enty.Key,enty.Value);

}

万年份的单身汉

关注

4
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
C#学习Day06

存储结构：基于哈希函数，将键映射到存储桶（bucket）中，每个桶包含一个链表，用于处理哈希冲突。存储结构：双向链表，每个节点包含一个数据元素和两个指针，分别指向前一个和后一个节点。作用：用于频繁插入和删除操作的场景，可以在任意位置高效插入和删除元素。作用：用于存储相同类型的元素，提供动态大小和便捷的插入、删除操作。存储结构：数组是固定大小的线性数据结构，存储在连续的内存块中。作用：用于存储相同类型的元素，可以通过索引快速访问元素。存储结构：基于数组的动态数组，大小可以根据需求动态调整。
复制链接

扫一扫