【第十一天】11c#今日小结

原创已于 2025-12-15 21:12:32 修改 · 562 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c# #开发语言

于 2025-12-15 21:09:26 首次发布

1.冒泡排序

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

namespace _03冒泡和选择
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //冒泡排序:俩两相比，如果前面大于后面的值这时候交换位置。
            //外循环要经过多少轮 一轮找出一个最值
            //内循环比较多少次 例如5个数比较4次即可，下一轮的时候 不用和上传最值进行比较，所以写内循环次数可以 这样写list.Count-1-i


            List<int> list = new List<int>() { 1,99,2,8,11,20,16,89};
            for (int i = 0; i < list.Count-1; i++)  // 为啥减-，例如数组的个数为5的话，只需要找出4个最值即可
            {
                for (int j = 0; j < list.Count-1-i; j++) // 内循环目的是为了要进行比较 并且交换位置 
                {                                        // j < list.Count-1-i ：之前已经找出最值，下轮没必要和上轮最值进行比较，
                    if (list[j]>list[j+1])  // 比较相邻位置交换位置 如果前面的大 交换位置
                    {
                        int temp = list[j];// 定义一个临时值 存储其中一个值
                        list[j] = list[j+1];// 把后面的值赋值给前面元素
                        list[j+1] =temp;// 把temp赋值给数组后面的元素
                    }
                }
            }
            foreach (var item in list)
            {
                Console.WriteLine(item+"----");
            }

            Console.ReadKey();
        }
    }
}

冒泡排序:俩两相比，如果前面大于后面的值这时候交换位置。
外循环要经过多少轮一轮找出一个最值
内循环比较多少次例如5个数比较4次即可，下一轮的时候不用和上传最值进行比较，所以写内循环次数可以这样写list.Count-1-i

2.选择排序

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

namespace _04选择排序
{
    internal class Program
    {
        static void Main(string[] args)
        {
            ArrayList list = new ArrayList() { 100,2,900,100,10,89,88};
            //选择排序: 每一轮找出最值的索引值，根据索引值再进行交换位置，所以交换的次数比冒泡排序的次数少,找出最值把最值放在已经排序的末尾

            for (int i = 0; i < list.Count - 1; i++)  
            {
                int minIndex = i;// 每一轮循环的 把i当成最小值的索引值, 0 1 2 3.4  5..
                for (int j   = i+1; j < list.Count; j++)  
                {
                    if (Convert.ToInt16(list[j]) < Convert.ToInt16(list[minIndex]))  // 取出最小值:list[minIndex],如果其中的一个元素比最小值还小，这时候list[j]最小值，
                                                                                     // 记录j的索引值

                    {
                         minIndex = j;
                    }
                }
                //在内循环外部进行交换位置
                if (i!=minIndex) //如果找到的最小的和初始化的赋值的最小的不一样进行交换，
                {
                    //list[minIndex] 和 list[i] 进行交换位置
                    int temp = Convert.ToInt16(list[i]);
                    list[i] = list[minIndex]; //最小值赋值给当前遍历的元素  已经排序的末尾
                    list[minIndex] = temp;
                }

            }
            Console.WriteLine(string.Join (",",list.ToArray())); //join() 把参数2的数组用参数1的符号进行拼接成一个字符串

            Console.ReadKey();
        }
    }
}

选择排序: 每一轮找出最值的索引值，根据索引值再进行交换位置，所以交换的次数比冒泡排序的次数少,找出最值把最值放在已经排序的末尾

3.字典

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

namespace _05字典
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //字典:包含了key(键)和value（值），简称为键值对，键是唯一的，值可以是任意类型的，字典是没有顺序的，只能通过键取值。
            //1创建字典的方法
            // Dictionary<string,string> 第一个string 键的类型; 第二个string值的类型
            Dictionary<string,string>  dic = new Dictionary<string,string>();

            //2添加键值对
            dic.Add("news1", "微信支付过年之后可能会被取消");//参数1键唯一，参数2是值
            dic.Add("news2", "柬埔寨生命科学园最大股东是国内gs");
            dic.Add("news3", "李连杰像个小朋友");

            //3取出值
            Console.WriteLine(dic["news1"]); //根据键取出值
            Console.WriteLine(dic.Values);//获取所有的值的集合
            Console.WriteLine(string.Join("-",dic.Values));
            foreach (var item in dic.Values)// 遍历字典字典里面所有值
            {
                Console.WriteLine(item+"+++++++++");
            }

            //4 取出键
            Console.WriteLine(dic.Keys);//获取所有的键的集合
            Array.ForEach(dic.Keys.ToArray(), v => Console.WriteLine(v + "??????")); //dic.Keys.ToArray() 转成数组类型

            //6 清空集合
            //dic.Clear();

            //7 修改值 
            dic["news3"] = "三胎补助";

            //8根据键进行删除
            dic.Remove("news3");

            //9 是否包含news3键
            Console.WriteLine(dic.ContainsKey("news3"));
            Console.WriteLine(dic.Count);//个数

            //最后 使用循环先遍历键 再根据键获取值
            foreach (var item in dic.Keys)
            {
                Console.WriteLine(dic[item]+"..................");
            }

            



            Console.ReadKey();
        }
    }
}

字典:包含了key(键)和value（值），简称为键值对，键是唯一的，值可以是任意类型的，字典是没有顺序的，只能通过键取值。

4.var定义变量

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

namespace _06var定义变量
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //定义整型和字符串等类型可以使用指定关键字
            int a = 10;
           
            string b = "hell";

            //还可以在定义使用var进行定义， var 可以接受任意类型的数据，var类型是根据赋值的时候确定类型
            var c = 10;
            var d = "ss";

            //dynamic 动态类型定义，也可以接收任意类型的数据
            dynamic name = "world";
            dynamic age = 10;
            Console.WriteLine(name);

            //dynamic和var区别
            //1 var是没有类型的 ，只有在赋值完之后才确定类型，dynamic就是一个类型
            //2 var 在定义时候 必须赋值，
            //3 使用dynamic时候 编码的时候没有对应的提示

            //var 使用的场景，在遍历数组的时候可以var接收数组元素
            //foreach (var item in collection)
            //{
            //}

            var dic = new Dictionary<string, int>();
            Console.WriteLine(dic.Count);


            /*强类型编程语言： 定义一个数据 一旦确定数据的类型，这个数据不能再赋值成其他类型 好处：类型安全 ，坏处需要类型的转换
             * C#强类型语法
             * 
             * 
             * 弱类型编程语言：定义一个数据 以后的代码可以修改数据的类型   坏处：类型不安全 ，好处不需要类型的转换
             * js弱类型
             * 
             * 
             */



            Console.ReadKey();
        }
    }
}

5.类_对象_方法

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

namespace _07类_对象_方法
{
    internal class Program
    {

        static void Main(string[] args)
        {
            //类: 具有相同属性和方法的集合，类就是数据的模版，不包含实际的数据 例如人类、电脑类 狗类 、猫类...

            //对象:类的实例化，对象才有实际的数据，如：一个人、一只鸟、一只猫、一只金毛、玩家A、玩家B、哥布林、牛头怪


            // 类成员：一个类中包含需要的信息(属性)和行为(方法)，这些信息我们统称为类成员。类成员用于记录这个类的信息，类成员包含（属性，字段 、方法）
            // 如：人类应该拥有名字、性别、年龄等属性，应该拥有吃、喝、拉、撒、睡等方法

            // 类和对象是面向对象编程语言的一大核心


           //2 创建对象语法:类名 对象名 = new 类名();
           People zhangsan = new People();
            //zhangsan.age 因为age是私有的 不能在外部访问
            zhangsan.Name = "李四";

            //3 非static的方法使用对象.方法名去调用
            zhangsan.Eat();
            

            //4 调用drink方法
            People p1 = new People();
            p1.Name = "张三";
            p1.Drink();


            People p2 = new People();
            p2.Name = "李四";
            p2.Drink();

            Console.ReadKey();
        }
    }

    //修饰符：就是类和属性、字段、方法使用的范围、
    //一般类默认修饰符internal ，
    //字段的默认修饰符是private 主要是保证数据的安全性，
    //属性一般定义public 主要是外部进行访问，
    // 方法一般定义成public

    //public:允许类、属性、字段、方法在类的外部进行访问，
    // private 只能在本类里面访问，
    //protected 不能在外部访问属性或者字段
    //internal :当前项目可以引用该类(后续演示)

    // 1 定义类语法: 修饰符 class 类名{}
    public class People
    {
       private int age; //字段名一般是小写， 默认是私有的

       protected int id;// 受保护的字段
       public  string Name { get; set; }// 属性 一般定义public 名称是大驼峰命名法则 

        //定义一个方法 无返回值的方法
        public void Eat()
        {
            
            Console.WriteLine("吃炸鸡");
           
        }
        //定义一个方法，
        public void Drink() 
        {   
            Console.WriteLine(this.Name+"喝可乐"); //在自己类访问可以省去this ，this代表目前创建的对象
        }

    }
}