C#数组的学习笔记

系统管理员 2023-08-17 15:42 108阅读 0赞

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace Project4
    {
        class Program
        {
            static void Main(string[] args)
            {
                //主程序入口
                //数组空间的定义方法
                //int[] arr = new int[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
                int[] arr = { 10, 32, 42, 55, 77, 3, 89, 13, 11, 100 };
                //数组翻转
                // reversed(arr);       
                //指定位置加入指定值     
                //insert(arr, 0, 1111);
                //指定数组删除指定值
                //deleteValue(arr, 115);
                deleteValue2(arr,77);
                //删除指定下标的元素
                //deletespecificSUB(arr, 0);
                                        //加入一个数组
                                        //int[] brr = {11,11,11,99};
                                        //insertArrdataTo(arr,2,brr);
                //指定数值替换
                //replace(arr, 77, 44);
                //Console.WriteLine(indexof(arr,11));
                // Console.WriteLine(lastIndexof(arr, 400));
                                         //从小到大排列
                                         // fromMintoMax(arr);
                                         //删除，指定位置到指定位置的值
                                           //deletekinddata(arr,0,2);
                                           // deletekinddata2(arr, 0, 2);//调用
                //  删除，指定位置指定长的元素
                //deletecountdata(arr,0,2);
                arrshow(arr);//经过上述变化，数组会变化
                Console.ReadKey();//Console.ReadLine();
    
            }
            /// <summary>
            /// 数组逆转
            /// </summary>
            /// <param name="arr">从外部传给的数组</param>
            static void reversed(int[] arr)
            {
                //int i = (int)(arr.Length / 2);
                //在数组中进行运算时，需要运算的次数:总长度的一半
                for (int a = 0; a < arr.Length / 2; a++)
                {
                    //借鉴于冒泡和选择法。即：选用一个中间变量，做临时的空间。
                    int t;
                    //将数组中倒数第一个（倒数第二个......）赋值给t。
                    t = arr[arr.Length - 1 - a];
                    //将对应的前半部分的值赋值给后部
                    arr[arr.Length - 1 - a] = arr[a];
                    //此时，地址名t内存的是对应的后部分值，赋值
                    arr[a] = t;
                }           
            }
            /// <summary>
            /// 在数组指定位置处插入一个指定的值
            /// </summary>由于数组长度不能改变，所以当值插入后，把后一个值覆盖掉
            /// <param name="arr">传入的数组</param>
            /// <param name="index">要插入的位置</param>
            /// <param name="value">加入的数值</param>
            static void insert(int[] arr,int index,int  value)
              //static void insert(int[] arr, index, value)错误地方：index value没有定义类型
            {
                //使用循环，倒叙方法
                  for(int i =arr.Length-1; i> index; i--)
                {
                    //直接使用前面的数覆盖后边的值）
                    arr[i] = arr[i - 1];
                }     
                  //赋值，将要给的值赋予index位置       
                arr[index] = value;            
            }
            /// <summary>
            /// 删除数组中指定的值，变量自定义        
            /// </summary>由于数组长度不能改变,册除一个值后
            /// 将后面所以值往前移，最后一个值改为0
            /// <param name="arr"> </param>
            /// <param name="value"> </param>
            static void deleteValue(int[] arr, int value)
            {
                //循环整个数组
                for (int i = 0; i <= arr.Length-1; i++)
                {
                    //在数组中找到指定数值
                    if (arr[i] == value)
                    {
                        //从当前位置开始，用后一个值覆盖前一个
                        for (int j = i; j < arr.Length - 1; j++)
                        {
                            arr[j] = arr[j + 1];
                        }
                    }
                    //另一种方法，利用indexof。
                    else
                    {
                        //Console.WriteLine("删除失败，未找到！");
                        return;
                    }
    
    
                }
                //数组末尾赋值0
                arr[arr.Length - 1] = 0;
            }
            //可以调用：
            static void deleteValue2(int[] arr, int value)
            {
                //定义一个变量，存储或许的下标
                int index = indexof(arr, value);            
                //删除改下标的值。为什么是index，而不是index++:因为，删除之后，index后边的一个值，就向前了一个格
                deletespecificSUB(arr, index);
            }
    
            /// <summary>
            /// 删除数组中指定下标的值,变量自定义
            /// </summary>
            /// <param name="arr"></param>
            /// <param name="index"></param>
            static void deletespecificSUB(int[] arr, int index)
            {
                //遍寻数组
                for(int i = 0;i <= arr.Length - 1; i++)
                {
                    //判断下标
                    if(i == index)
                    {    
                        //从该处遍寻数组         
                        for(int j =i;j< arr.Length - 1; j++)
                        {
                            //用后一个值覆盖前一个值
                            arr[j] = arr[j + 1];
                        }
                    }
                }
                //最后一个赋0
                arr[arr.Length - 1] = 0;
            }
            /// <summary>
            /// 在数组指定位置处，插入另一个数组的值
            /// </summary>被插入的数组，此数组的长度一定要小于arr的长度
            /// <param name="arr"> </param>
            /// <param name="index">为插入的开始下标</param>
            static void insertArrdataTo(int[] arr,  int index,int [] brr)
            {
                //加限制条件if，覆盖问题。建立一个新的数组
                //数组一和数组二的总长度小于数组一的长时
                //先挪后运算
                
                for(int i = index; i< index+brr.Length; i++)
                {
                    
                    //当要插入的数组元素和原数组元素的和长度大于原数组长
                    
                        //将原数组元素向后移动
                        arr[i + brr.Length] = arr[i];//wu  
                        //arr[i] = arr[i - brr.Length]; 
                        //填入数据  
                          
                    
                }
                //wang:循环 放入数值。还要考虑插入的个数 
                for (int j = 0; j < brr.Length&&index<arr.Length; j++,index++)
                { 
                    arr[index] = brr[j];
                }
                   
            }
            /// <summary>
            /// 把数组中的指定的值，换成指定的值
            /// </summary>
            /// <param name="arr"> 数组</param>
            /// <param name="oldValue">要替换的数</param>
            /// <param name="newValue">给予的数值</param>
            static void replace(int[] arr, int oldValue, int newValue)
            {
                //遍寻数组中的所有元素
               for(int i =0; i < arr.Length; i++)
                {
                    //寻找
                    if(arr[i] == oldValue)
                    {
                        //在该处做替换
                        arr[i] = newValue;
                    }
                }
            }
            /// <summary>
            ///  返回数组总指定的值第一次出现的位置
            /// </summary>
            /// <param name="arr"> </param>
            /// <param name="value"> </param>
            /// <returns></returns>     
            static int indexof(int[] arr,int value)
            {
                for (int i = 0; i < arr.Length; i++)
                {
                    //当if else后边仅一条语句时，可不用括号
                    //如果查到与外部给的数值相等的数，那么返回该下标
                    if (arr[i] == value)   return i;                
                }
                //若查询不到，返回-1；
                    return -1;              
            }
            /// <summary>
            /// 返回数组中指定的值，最后一次出现的位置
            /// </summary>
            /// <param name="arr"></param>
            /// <param name="value"></param>
            static int lastIndexof(int[] arr,int  value)
            {
                //用逆序的思想，倒数的第一个，为正的最后一个
                for(int i = arr.Length - 1; i >= 0; i--)
                {
                    if(arr[i] == value)
                    {
                        //函数执行到这里直接返回了
                        return i;
                    }
                }
                //因为数组中的下标是从0开始。
                return -1;//返回任何一个正整数均不合理       
            }
            /// <summary>
            /// 数组元素，由小到大排列
            /// </summary>
            /// <param name="arr"></param>
            static void fromMintoMax(int[] arr)
            { 
                //交换次数：应是两次循环 遍布
                for (int i = 1; i < arr.Length - 1; i++)
                { 
                    for (int j = 0; j < arr.Length - i; j++)
                    {
                        int t;
                        if (arr[j] > arr[j + 1])
                        {
                            t = arr[j];
                            arr[j] = arr[j + 1];
                            arr[j + 1] = t;
                        }
                    }
                }
     
            } 
            /// <summary>
            /// 删除数组中指定的某一段值，从指定下标删除到指定的下标
            /// </summary>
            /// <param name="arr"></param>
            /// <param name="sIndex">开始删除的起始位置</param>
            /// <param name="eIndex">删除的结束位置，但不包括结束位置的值</param>
            static void deletekinddata(int[] arr,int sIndex,int eIndex)
            {
                //最后一位不包括，所以是eIndex > arr.Length。判断
                if (sIndex < 0 || eIndex > arr.Length) return;
                int temp = sIndex;
                for (int j = eIndex; j < arr.Length; j++)
                {
                    arr[temp] = arr[j];
                    //arr[sIndex] = arr[j];sIndex的值并没有发生变化
                    temp++;
                    // sIndex++;若直接使用，则其值发生变化，赋值循环无法正常使用
                }
                //判断清零的个数，进而赋值为零。
                for (int x=arr.Length-1;x>= arr.Length-(eIndex-sIndex); x--)
                {
                    arr[x] = 0;
                }
            }
            /// <summary>
            /// 末尾的元素依然删除了。
            /// </summary>
            /// <param name="arr"></param>
            /// <param name="sIndex"></param>
            /// <param name="eIndex"></param>
            static void deletekinddata2(int[] arr, int sIndex, int eIndex)
            {
                if (eIndex < 0 || sIndex > arr.Length) return;
                //i :表示要删除的个数
                for(int i = 0;i< eIndex-sIndex;i++)
                {
                    //deletespecificSUB:删除指定下标；删除一个数之后，数组中的数值会向前移动一格。
                    //那么删除的位置应该是sIndex
                    deletespecificSUB(arr, sIndex);
                }
            }
    
    
    
            /// <summary>
            /// 删除数组中指定个数的值,从指定位置删除，往后删除指定的个数
            /// </summary>
            /// <param name="arr"></param>
            /// <param name="sIndex">删除的起始位置</param>
            /// <param name="Length">总共要删除多少个，不包括最后一位</param>
            static void deletecountdata(int[]arr,int sIndex, int Length)
            {
                for(int i =0; i < arr.Length; i++)
                {
                     for(int j=sIndex + Length - 1;j >= sIndex;j--)
                    {
                        //arr[j] = 0;
                        for(int x= sIndex + Length - 1;x< arr.Length-1; x++)
                        {
                            int t;
                            t= arr[x + 1];
                            arr[x + 1] = arr[x];
                            arr[x] = t;
                        }
                    }
                     
                  
                }
                for(int y = arr.Length - 1; y >= arr.Length - Length; y--)
                {
                    arr[y] = 0;
                }
            }         
            //显示数组中的所有的元素
            static void arrshow(int[] arr)       //  传入参数时，定义类型
            {
                for (int i = 0; i < arr.Length; i++)
                {
                    Console.Write(arr[i] + " ");
                }  
            }
             
        }
    }

转载于:https://www.cnblogs.com/allyh/p/11456430.html