C#数组及其排序和方法

最新推荐文章于 2025-11-23 21:07:11 发布

原创最新推荐文章于 2025-11-23 21:07:11 发布 · 442 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#java #算法 #数据结构 #c# #开发语言 #visual studio

ModelEngine·创作计划征文活动 10w+人浏览 1.4k人参与

*数组：

数组是存储一组相同类型数据的集合

数组本也是一种数据类型他属于引用数据类型

数组分为一维多维交错数组一般情况下一维数组就简称数组

•一维数组：(定义、最值计算、增删改查、总和平均值、去重)

•一维数组定义:

//1.变量类型[] 数组名;   
//只是声明了一个数组 但并没有开房
//变量类型 可以是我们学过的所有变量类型 
int[] arr1;//声明了一个用于存储int类型数据的数组
//2.变量类型[] 数组名 = new 变量类型[数组的长度];
int[] arr2 = new int[10];//这种方式 相当于开了10个房间 可以在这个数组里面存储10个数据  但房间里面的int值默认为0
//数组初始化之后，c# 或自动在开辟的空间里面填充一个默认值进行占位
//数字类型默认值就是 0  bool类型的默认值是 false  char类型的默认值是 \0   string类型的默认值是 null（空）
//不确定的话可以  Console.WriteLine(default(类型));去判断
//3.变量类型[] 数组名 = new 变量类型[数组的长度]{内容1,内容2,.....,内容n};
int[] arr3 = new int[5] { 1, 2, 3, 4, 5 };//这种方式 相当于开了5个房间 但房间里面的int值y依次为1, 2, 3, 4, 5
//4.变量类型[] 数组名 = new 变量类型[]{内容1,内容2,.....,内容n};
int[] arr4 = new int[] { 1, 2, 3, 4, 5 };//后面的内容就决定了 数组的长度"房间数"
//5.变量类型[] 数组名 = {内容1,内容2,.....,内容n};
int[] arr5 = { 1, 2, 3, 4, 5 };//后面的内容就决定了 数组的长度"房间数"
//声明的变量类型是什么 房间数就填什么类型
bool[] arr6 = new bool[3] {true,true,false};

•一维数组最值计算:

int[] arr = { 10, 20, 30, 5, 8, -10, -15, 100, 70 };
 // 求最大值
 int max = arr[0];
 // 求最小值
 int min = arr[0];
 for (int i = 1; i < arr.Length; i++)
 {
     if (max < arr[i])
     {
         max = arr[i];
     }
     if (min > arr[i])
     {
         min = arr[i];
     }
 }

•一维数组增删改查(CRUD):

//数组的使用
int[] arry = { 1, 2, 3, 4, 5 };
//1.数组的长度   数组变量名.Length
Console.WriteLine(arry.Length);//5

//2.获取数组中的元素
//数组中的索引或下标 他们是从0开始的
//通过 索引和下标去 获得数组中的某一个元素的值时  一定不能越界 数组的房间号 范围 是 0~（Length-1)
Console.WriteLine(arry[0]);//1
Console.WriteLine(arry[2]);//3
Console.WriteLine(arry[4]);//5

//3.修改数组中的元素-Update
arry[0] = 99;
Console.WriteLine(arry[0]);//99
 int[] qq = { 10, 20, 30, 5, 8, -10, -15, 100, 70 };
 bool iss = false;
 for (int i = 0; i < qq.Length; i++)
 {
     if (qq[i] == 100)
     {
         qq[i] = 120;
         iss = true;
     }
 }
 if (iss)
 { Console.WriteLine("100成功修改为120"); }
 else
 { Console.WriteLine("未找到,修改失败"); }

//4.遍历数组 通过循环 快速获取数组中的每一个元素
for (int i = 0; i < arry.Length; i++)
{
    Console.WriteLine(arry[i]);//99,2,3,4,5
} 
//使用foreach进行遍历
//优点：简单简洁
//缺点：
//1.无法访问当前数据所在的索引
//2.无法修改数组
//3.无法从中间终止
//格式: foreach (数组的数组类型 变量名 in 数组名)
foreach (int arryy in arry)
{
    //arryy就表示数组中的每一项数据
    Console.WriteLine(arryy);//99,2,3,4,5
} 

//5.增加数组元素-Create
//数组初始化以后 是不能够 直接添加新的元素的
int[] arry2 = new int[arry.Length + 1];
//搬家
for (int i = 0; i < arry.Length; i++)
{
    arry2[i] = arry[i];
}
arry2[arry.Length] = 119;
arry = arry2;
for (int i = 0; i < arry.Length; i++)
{
    Console.WriteLine(arry[i]);//99,2,3,4,5,119
}

//6.删除数组元素-Delete
//数组初始化以后 是不能够 直接删除元素的
//也是搬家的原理
int[] arry3 = new int[5];
//搬家
for (int i = 0; i < arry3.Length; i++)
{
    arry3[i] = arry[i];
}
arry = arry3;
Console.WriteLine(arry.Length);//5
int[] qq = { 10, 20, 30, 5, 8, -10, -15, 100, 70 };
//删除指定的数据
//比如删除整数:100
//1.先创建一个新数组:长度为旧数组的长度-1
int[] newArr = new int[qq.Length - 1];
//2.遍历旧数组依次取出整数数据，但是遇到100需要跳过
// 定义一个新数组的索引变量
int index = 0;
for (int i = 0; i < qq.Length; i++)
{
    if (qq[i] == 100)
    {
        continue;//跳出循环,继续下次循环
    }
    newArr[index++] = qq[i];
}
//3.替换
qq = newArr;

//7.查找数组中的元素-Retrieve
//99 2 3 4 5
//要查找 3 这个元素在哪个位置
//只要通过遍历才能确定 数组中 是否存储一个目标元素
int a = 3;
for (int i = 0; i < arry.Length; i++)
{
    if (a == arry[i])
    {
        Console.WriteLine("和a相等的元素在{0}索引位置", i); //a相等的元素在2索引位置
        break;
    }
}

•总和和平均值计算:

int[] qq = { 11, 20, 30, 13, 10, 73 };
//计算总和值
int sum = 0;
for (int i = 0; i < qq.Length; i++)
{
    //sum = sum + qq[i];
    //简化
    sum += qq[i];
}
//平均值
int cc = sum / qq.Length;
Console.WriteLine(cc);

•去重操作:

int[] arr = { 10, 20, 30, 5, 8, -10, 10, -15, 100, 20, 70, 100, 10 };
//去重操作:标记去除
//把重复的元素替换为:-1
//怎么替换:-1
int count = 0;
for (int i = 0; i < arr.Length; i++)
{
    for (int j = i + 1; j < arr.Length; j++)
    {
        if (arr[i] == arr[j] && arr[j] != -1)
        {
            arr[j] = -1;
            count++;
        }
    }
}
//定义新数组:长度为旧数组长度-1
int[] qa = new int[arr.Length - count];
//去除-1的值
//定义一个新数组的索引变量
int index = 0;
for (int i = 0; i < arr.Length; i++)
{
    if (arr[i] == -1)
    {
        continue;
    }
    qa[index++] = arr[i];
}
arr = qa;
foreach (int i in arr)
{
    Console.WriteLine(i + "");
}

•二维数组：

//二维数组 是使用两个下标（索引）来确定元素的数组
//同一变量类型的 行列数据集合
//两个下标可以理解成 行标 和 列标
//比如矩阵
// 1 2 3
// 4 5 6
//可以用二维数组 int[2，3]表示
//好比 两行 三列的数据集合
//1.变量类型[,] 二维数组变量名;
int[,] arr;//申明过后 会在后面进行初始化
//2.变量类型[,] 二维数组变量名=new 变量类型[行,列];
int[,] arr2 = new int[3,3];
//3.变量类型[,] 二维数组变量名=new 变量类型[行,列]{{0行内容1,0行内容2,....,0行内容n},...,{n行内容n......}};
int[,] arr3 = new int[3, 3] { { 1, 2, 3 }, 
                              { 4, 5, 6 }, 
                              { 7, 8, 9 } };
//4.变量类型[,] 二维数组变量名=new 变量类型[,]{{0行内容1,0行内容2,....,0行内容n},{n行内容n......}};
int[,] arr4 = new int[,] { { 1, 2, 3 },
                           { 4, 5, 6 } };
//5.变量类型[,] 二维数组变量名={{0行内容1,0行内容2,....,0行内容n},{n行内容n......}};
int[,] arr5 =  { { 1, 2, 3 },
                 { 4, 5, 6 },
                 { 7, 8, 9 } };

int[,] array = new int[,] { { 1, 2, 3 },
                            { 4, 5, 6 } };
//1.二维数组的长度
//我们要获取 行和列分别是多长
// 数组名.GetLength(0)  得到多少行  
Console.WriteLine(array.GetLength(0));//2
// 数组名.GetLength(1)  得到多少列  
Console.WriteLine(array.GetLength(1));//3
//2.获取二维数组中的元素
//注意：第一个元素的索引是0 最后一个元素的索引 肯定是(长度-1)
Console.WriteLine(array[0, 1]);//2
Console.WriteLine(array[1, 2]);//6
//Console.WriteLine(array[3, 2]);//注意这里是错误的 不能越界
//3.修改二维数组中的元素
array[0, 0] = 99;
Console.WriteLine(array[0, 0]);//99
//4.遍历二维数组
for (int i = 0; i < array.GetLength(0); i++)
{
    for (int j = 0; j < array.GetLength(1); j++)
    {
        // i 行 0 1
        // j 列 0 1 2
        Console.WriteLine(array[i, j]);
    }
}
//5.增加数组的元素
//数组 声明初始化以后 是不能够 在原有基础上 添加新的元素的
int[,] array2 = new int[3, 3];
for (int i = 0; i < array.GetLength(0); i++)
{
    for (int j = 0; j < array.GetLength(1); j++)
    {
        array2[i, j] = array[i, j];
    }
}
array = array2;
array[2, 0] = 7;
array[2, 1] = 8;
array[2, 2] = 9;

for (int i = 0; i < array.GetLength(0); i++)
{
    for (int j = 0; j < array.GetLength(1); j++)
    {
        Console.WriteLine(array[i, j]);
    }
}
//6.删除数组的元素
int[,] array3 = new int[2, 3];
for (int i = 0; i < array.GetLength(0); i++)
{
    for (int j = 0; j < array.GetLength(1); j++)
    {
        array3[i, j] = array[i, j];
    }
}
array = array3;   
for (int i = 0; i < array.GetLength(0); i++)
{
    for (int j = 0; j < array.GetLength(1); j++)
    {
        Console.WriteLine(array[i, j]);
    }
}

•交错数组:

交错数组是数组的数组,每个维度的数量可以不同

交错数组可以存储同一类型的 m行不确定列的数据

注意:二维数组的每行的列数相同,交错数组每行的列数可能不同

//1. 变量类型[][] 交错数组名;
int[][] arr1;

//2. 变量类型[][] 交错数组名 = new 变量类型[行数][];
int[][] arr2 = new int[3][];//第二个[]应该空下来,因为交错数组每行的列数可能不同

//3. 变量类型[][] 交错数组名 = new 变量类型[行数][]{一维数组1,一维数组2,.......};
int[][] arr3 = new int[3][] { new int[] { 1, 2, 3 }, 
                              new int[] { 1, 2 }, 
                              new int[] { 1 } };

//4. 变量类型[][] 交错数组名 = new 变量类型[行数][]{一维数组1,一维数组2,.......};
int[][] arr4 = new int[][] { new int[] { 1, 2, 3 }, 
                             new int[] { 1, 2 },
                             new int[] { 1 }, 
                             new int[] { 1, 2 } };

//5. 变量类型[][] 交错数组名 = new 变量类型[行数][]{一维数组1,一维数组2,.......};
int[][] arr5 = { new int[] { 1, 2, 3 }, 
                 new int[] { 1, 2 },
                 new int[] { 1 } };

//1.数组的长度
//行
Console.WriteLine(array.GetLength(0));//2
//得到某一行的列数
Console.WriteLine(array[0].Length);//3
//2.获取交错数组中的元素
//注意不要越界
Console.WriteLine(array[0][1]);//2
Console.WriteLine(array[1][1]);//5
//3.修改交错数组中的元素
array[0][1] = 99;
Console.WriteLine(array[0][1]);//99
//4.遍历交错数组
for (int i = 0; i < array.GetLength(0); i++)
{
    for (int j = 0; j < array[i].Length; j++)
    {
        Console.Write(array[i][j] + " ");
    }
    Console.WriteLine();
}

•数组的属性和方法:

//所有的数组都是Array类的实例，Array类提供了一系列属性和方法
    int[] ints = { 1, 2, 3, 4, 5 };
    int[,,] ints1 =
    {
        {
            {1,2 }, {2,3},
        },{
            {1,2 },{3,4},
        },{
            {1,2 },{3,4},
        }
    };
    // .Length 表示32位的整数，表示数组的长度
    Console.WriteLine(ints.Length);//5
    // .LongLength 表示64位的整数，表示数组的长度
    Console.WriteLine(ints.LongLength);//5
    // .Rank 返回数组的维度
    Console.WriteLine(ints.Rank);//1
    Console.WriteLine(ints1.Rank);//3
    // 方法
    // Array.Clear(); 将数组中指定的数据恢复默认值
    int[] ints2 = { 2, 2, 3, 4, 5, 6, 7 };
    //参数1：需要改变的数组
    //参数2：数组开始改变的位置
    //参数3：改变的个数
    Array.Clear(ints2, 1, 4);
    foreach (var item in ints2)
    {
        Console.WriteLine(item);//2000067
    }
    // Array.Copy(); 将数组中指定的数据进行替换
    int[] ints3 = new int[20];
    //将参数1里面的数据替换到参数2，由参数3决定替换几个
    Array.Copy(ints2, ints, 5);
    foreach (var item in ints)
    {
        Console.WriteLine(item);//20000
    }
    int[] ints4 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    int[] ints5 = new int[6];
    //参数1：被赋值的数组
    //参数2：复制的开始索引
    //参数3：复制到目标数组
    //参数4：目标数组开始的索引
    //参数5：复制的个数
    Array.Copy(ints4, 2, ints5, 0, 4);
    foreach (int item in ints5)
    {
        Console.WriteLine(item);//345600
    }
    // Array.Reverse(); 反转数组
    Array.Reverse(ints5);
    foreach (int item in ints5)
    {
        Console.WriteLine(item);//006543
    }
    // Array.IndexOf(); 查找对应数据 在数组中 首次出现 的位置，有则返回索引，无则返回-1
    Console.WriteLine(Array.IndexOf(ints5, 55));//-1
    Console.WriteLine(Array.IndexOf(ints5, 3));//5
    //参数3是指定开始查询的索引 
    Console.WriteLine(Array.IndexOf(ints5, 0, 2));//-1
    //指定查询的个数 从ints5中查3从索引4开始查，查2个
    Console.WriteLine(Array.IndexOf(ints5, 3, 4, 2));//-1

internal class Program
{
    static void Main(string[] args)
    {
         //下面的方法都是Array类上的方法 需要使用Array.xxx调用
        // Array.Find(数组名, 方法名);  根据传入的 数组和方法 从前往后 查询，第一个满足条件 的值
        int[] ages = { 19, 17, 32, 60, 16, 15 };     
        //Find 工作原理：循环该数组，并且每次循环都会调用这个方法 把当前的值通过参数传入到函数内部，如果方法返回了true，则Find直接返回当前这个数
        // 参数1：查询的数组
        // 参数2：一个函数，这个函数应该返回一个bool，会根据返回的bool值来判断当前的数值是否满足条件
        // 如果数组中没有满足条件的  则返回该类型的默认值
        //需求:查询数组中第一个年龄不满足18的 
        Console.WriteLine(Array.Find(ages, FindAge));//17
        //需求：返回数组中第一个奇数
        Console.WriteLine(Array.Find(ages, Find1));//19
        //需求：返回数组中同时能整除3和5
        Console.WriteLine(Array.Find(ages, Find2));//60
        // Array.FindIndex(数组名, 方法名);  根据传入的 数组和方法 从前往后 查询，第一个满足条件 的索引
        //如果都不满足返回-1
        Console.WriteLine(Array.FindIndex(ages, FindAge));//1
        Console.WriteLine(Array.FindIndex(ages, Find1));//0
        Console.WriteLine(Array.FindIndex(ages, Find2));//3
        // Array.FindLast(数组名, 方法名);  根据传入的 数组和方法 从后往前 查询，第一个满足条件 的值
        Console.WriteLine(Array.FindLast(ages, FindAge));//15
        // Array.FindLastIndex(数组名, 方法名);  根据传入的 数组和方法 从后往前 查询，第一个满足条件 的索引
        Console.WriteLine(Array.FindLastIndex(ages, FindAge));//5
        // Array.FindAll(数组名, 方法名);  查询所有满足条件的数据  会把符合条件的数据统一放到数组里面
        int[] arr = Array.FindAll(ages, FindAge);
        foreach (var item in arr)
        {
            Console.WriteLine(item);//17 16 15
        }
        // Array.TrueForAll(数组名, 方法名);  判断 数组中 的数据 是否 全部 满足条件 (全部满足返回True 有一个不满足就返回False)
        int[] ints = { 2, 21, 221 };
        Console.WriteLine(Array.TrueForAll(ints, Find3));//False
        // Array.Exists(数组名, 方法名);  判断 数组中 的数据是 有一个 满足条件的 (一个满足返回True，都不满足就返回False)
        Console.WriteLine(Array.Exists(ints, Find3));//True
        // Array.ForEach(数组名, 方法名);  遍历数组
        Array.ForEach(ints, Find4);       
    }   
    public static bool FindAge(int value)
    { //需要查询数组的条件
        return value < 18;
    }
    public static bool Find1(int value)
    { return value % 2 != 0; }
    public static bool Find2(int value)
    { return value % 3 == 0 && value % 5 == 0; }
    public static bool Find3(int value)
    { return value % 2 == 0; }
    public static void Find4(int value)
    {
        Console.WriteLine(value);//2 21 221
    }
}

static void Main(string[] args)
    {
        //Array实例上的方法，需要使用 数组.xxx调用
        string[] str1 = { "蔡徐", "罗志", "吴亦" };
        string[] str2 = new string[5];
        //将str1复制到str2，从str2的索引为1的位置开始
        str1.CopyTo(str2, 1);
        // Array.ForEach(数组名, 方法名);  遍历数组
        Array.ForEach(str2, Find5);
        int[,,] ints1 = new int[10, 9, 8];
        Console.WriteLine(ints1.GetLength(0));//10
        Console.WriteLine(ints1.GetLength(1));//9
        Console.WriteLine(ints1.GetLongLength(1));//9
        str1.SetValue("糖果超甜", 1);
        //等同于str1[1]="糖果超甜" //set设置 get获取           
        Console.WriteLine(str1.GetValue(1));
    }
    public static void Find5(string value)
    { Console.WriteLine(value); }

•冒泡排序、选择排序、Sort排序:

冒泡排序原理:一般认为小值排前面,大值排后面,排序结果为从小到大的顺序

规则:每轮每次拿相邻的两个元素进行比较,小值放前面,大值放后面,每一轮结束后都会找到当前轮中的最大值放到数组的最后面

轮数为:数组元素-1

选择排序原理:每轮每次都先拿第一个元素依次和后面的元素进行大小比较,排序结果为从小到大的顺序

每次比较中,小值放前面,大值放后面,每一轮结束后,都会找到最小值,放到了第一个位置上

轮数为:数组元素-1

// Array.Sort  元素从小到大排序
 int[] ints = { 3, 66, 4, 9, 88, 55, 1, 7 };
 Array.Sort(ints);
 foreach (var item in ints)
 { Console.WriteLine(item); }

//冒泡排序 是一种简单的排序算法 它通过重复遍历排序列表，比较相邻两个元素大小交换他们的位置来排序
//外面申明一个标识 来表示 该轮是否进行了交换
bool isSort = false;
for (int i = 0; i < ints.Length - 1; i++)//i-->轮数
{
    //每一轮开始时 默认没有进行过交换
    isSort = false;
    for (int j = 0; j < ints.Length - 1 - i; j++)//j-->数组元素索引
    {
        if (ints[j] > ints[j + 1])
        {
            isSort = true;
            int a = ints[j] 
            ints[j] = ints[j + 1];
            ints[j + 1] = a;
            //也可以使用元祖操作
            //数组类型必须是单一类型的.元祖操作,可以存储不同数据类型的数据,而且还支持切片操作
            //切片:int[] aee = {1-100-2};
            //(ints[j] , ints[j + 1]) = (ints[j + 1] , ints[j]);
        }
    }
    //当一轮结束过后 如果isSort这个表示还是false
    //那就意味着 已经是最终的序列了 不需要在判断交换了
    if(isSort == false)
    { break; }
    foreach (var item in ints)
    { Console.WriteLine(item); }
}

//选择排序
for (int i1 = 0; i1 < ints.Length - 1; i1++)
{
    for (int j1 = 0; j1 < ints.Length; j1++)
    {
        if (ints[i1] > ints[j1])
        {
            (ints[i1] , ints[j1]) = (ints[j1] , ints[i1]);
        }
    }
}