OStack程序员社区-中国程序员成长平台 › 门户 › 编程› Node.js›Node.js教程

第7天c#基础冒泡排序选择排序二维数组交错数组

原作者: [db:作者] 来自: [db:来源] 收藏邀请

1. 算法步骤

2.动图演示

3.代码实现

　　　　　　　int[] arr = {3,5,9,2,1,4,6,8,7,0};

            //1.依次比较两个相邻的元素，比较（大于或小于）成功后交换两个元素
            //0与1比较， 1与2比较， 2与3比较......  如果做大于比较，那么一轮之后最后一个元素就是最大值

            ////第0次比较   0与1比较
            //if (arr[0] > arr[1])
            //{
            //    //交换的过程
            //    int temp = arr[0];
            //    arr[0] = arr[1];
            //    arr[1] = temp;
            //} 

            ////第1次比较   1与2比较
            //if(arr[1] > arr[2])
            //{
            //    int temp = arr[1];
            //    arr[1] = arr[2];
            //    arr[2] = temp;
            //}

            ////第i次比较  i与 i + 1比较
            //if (arr[i] > arr[i + 1])
            //{
            //    int temp = arr[i];
            //    arr[i] = arr[i + 1];
            //    arr[i + 1] = temp;
            //}

            //6个元素比较5次， 3个元素比较2次， length元素比较length - 1次

            //比较过程都是重复
            //第0轮比较，比较次数  arr.Length - 1 - 0
            //for (int j = 0; j < arr.Length - 1; j++)
            //{
            //    if (arr[j] > arr[j + 1])
            //    {
            //        int temp = arr[j];
            //        arr[j] = arr[j + 1];
            //        arr[j + 1] = temp;
            //    }
            //}


            ////2.继续从未排序的数组中依次比较相邻两个元素，比较（大于或小于）成功后交换两个元素
            ////未排序的元素是9个 数组长度是10个  比较次数是8次，   Length-1-1
            ////第1轮比较， 比较次数  arr.Length - 1 - 1
            //for (int j = 0; j < arr.Length - 1 - 1; j++)
            //{
            //    if (arr[j] > arr[j + 1])
            //    {
            //        int temp = arr[j];
            //        arr[j] = arr[j + 1];
            //        arr[j + 1] = temp;
            //    }
            //}

            ////3.继续从未排序的数组中依次比较相邻两个元素，比较（大于或小于）成功后交换两个元素
            ////重复该步骤
            ////第2轮比较， 比较次数  arr.Length - 1 - 2
            //for (int j = 0; j < arr.Length - 1 - 2; j++)
            //{
            //    if (arr[j] > arr[j + 1])
            //    {
            //        int temp = arr[j];
            //        arr[j] = arr[j + 1];
            //        arr[j + 1] = temp;
            //    }
            //}

            //4个元素，3轮全部排完，  length个元素， length-1轮全部排完
            //i控制 第几轮
            for (int i = 0; i < arr.Length - 1; i++)
            {
                for (int j = 0; j < arr.Length - 1 - i; j++)
                {
                    if (arr[j] > arr[j + 1])
                    {
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }

            }


            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write(arr[i] + "\t");
            }

选择排序

1. 算法步骤

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕。

2. 动图演示

3.代码实现

            int[] arr = { 3, 5, 9, 2, 1, 4, 6, 8, 7, 0 };

            //1.在当前数组中找到最大的或最小的元素与当前数组的第0位做交换

            ////找到最大的
            ////假设当前第0位就是最大的
            //int max = arr[0];
            ////最大的索引
            //int maxIndex = 0;
            ////当前最大值依次与每一位元素做比较, 已经假设第0位最大，那么第0位无需比较
            //for (int j = 1; j < arr.Length; j++)
            //{
            //    //如果当前元素比假设的最大，那么当前元素就是最大的
            //    if (arr[j] > max)
            //    {
            //        max = arr[j];
            //        maxIndex = j;
            //    }
            //}

            ////最大的元素就是max
            ////当前的第maxIndex位与第0位元素做交换
            //int temp = arr[0];
            //arr[0] = arr[maxIndex];
            //arr[maxIndex] = temp;

            //2.在未排序的数组中找到最大的或最小的与未排序数组的第0位做交换
            //9, 5, 3, 2, 1, 4, 6, 8, 7, 0
            // 未排序数组不包含9，与未排序数组的第0位交换，实际是与整个数组的第1位做交换

            //假设未排序的数组的第0位，也就是实际数组的第1位是最大的
            //max = arr[1];
            //maxIndex = 1;

            //for (int j = 2; j < arr.Length; j++)
            //{
            //    if (arr[j] > max)
            //    {
            //        max = arr[j];
            //        maxIndex = j;
            //    }
            //}
            ////第maxIndex与第1位做交换
            //temp = arr[1];
            //arr[1] = arr[maxIndex];
            //arr[maxIndex] = temp;

            //3.重复上述过程
            for (int i = 0; i < arr.Length - 1; i++)
            {
                //i控制的第几轮
                //当第0轮时，假设第0位是最大的
                //当第1轮时，假设第1位是最大的
                //当地i轮时，假设第i为是最大的
                int max = arr[i];
                //最大的索引
                int maxIndex = i;
                //当前最大值依次与每一位元素做比较, 已经假设第0位最大，那么第0位无需比较
                //第0轮时，从第1位开始比较
                //第1轮时，从第2位开始比较
                //第i轮时，从第i + 1位开始比较
                for (int j = i + 1; j < arr.Length; j++)
                {
                    //如果当前元素比假设的最大，那么当前元素就是最大的
                    if (arr[j] > max)
                    {
                        max = arr[j];
                        maxIndex = j;
                    }
                }

                //最大的元素就是max
                //第0轮时，最大位置与第0位做交换
                //第1轮时，最大位置与第1位做交换
                //第i轮时，最大位置与第i位做交换
                int temp = arr[i];
                arr[i] = arr[maxIndex];
                arr[maxIndex] = temp;
            }


            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write(arr[i] + "\t");
            }

二维数组

1.将数据存储在类似于二维空间中

2.在二维数组中定位某一个值需要2个角标

3.定义

            int[,] array = new int[3, 4];  //定义一个长度为3行4列的二维数组
            int[,] array1 = new int[3, 4] {
                                            {1,2,3,4},
                                            {5,6,7,8 },
                                            {9,10,11,12 }
                                            };              //定义长度并赋值
            int[,] array2 = {
                                {1,2,3,4},
                                {5,6,7,8 },
                                {9,10,11,12 }
                            };                             //省略长度 直接赋值

            int[,] array3;                                //只定义二维数组名
            array3 = new int[3, 4] {                      //再赋值时先给长度再赋值
                                        { 1,2,3,4},
                                        { 5,6,7,8 },
                                        { 9,10,11,12 }
                                    };
            int[,] array4;                                  //只定义二维数组名
            //array4 =  {                                     //再赋值时不给长度会报错
            //                { 1,2,3,4},
            //                { 5,6,7,8 },
            //                { 9,10,11,12 }
            //            };
　　　　　　　// 遍历二维数组
            for (int i = 0; i < array.GetLength(0); i++)　　　　//获取二维数组长度arr.GetLength(0); //0为行 1为列
            {
                for (int j = 0; j < array.GetLength(1); j++)　　//列
                {
                    Console.Write(array3[i,j]+ "\t");            //取值也需要两个角标
                }
                Console.WriteLine();
            }

4.赋值和取值

交错数组

1.数组的数组，每一行都是一个长度不同的一维数组

定义和赋值

            int[][] arr = new int[5][]; //交错数组第一个中括号可以给数据，表示多少行， 因为交错数组每一列的长度不固定，所以可以不给
            for (int i = 0; i < arr.Length; i++)   //获取交错数组的长度跟一维数组一样，用arr.Length
            {
                arr[i] = new int[i+1];             //定义多少列的时候 arr[i]前面不加int[] ，直接定义列的长度
            }

            int[][] arr2 = new int[3][]{
                                        new int[] {1},
                                        new int[] {2,3},
                                        new int[] {3,4,5}
                                        };          //3行的交错数组

遍历数组

方法1

foreach (int[] item in arr)                             //遍历方法1 foreach
{
    foreach (var tmp in item)
    {
        Console.Write(tmp+"\t");
    }
    Console.WriteLine();
}

方法2

for (int i = 0; i < arr2.Length; i++)                   //数组遍历2
{
    for (int j = 0; j < arr2[i].Length; j++)
    {
        Console.Write(arr2[i][j]+"\t");
    }
    Console.WriteLine();
}