C#数组元素冒泡、选择、插入排序

客官°小女子只卖身不卖艺 2023-03-01 12:47 14阅读 0赞

[面试 - 数组分割法反转数组元素][-]

using DocumentFormat.OpenXml.Wordprocessing;
    using System;
    using System.Collections.Generic;
    using System.Text;
    
    namespace KnowledgePoint
    {
        class _28_ArrayElements
        {
            static void Main(string[] args)
            {
                Random rd = new Random();
                int[] rdNumArr = new int[10];
                for (int i = 0; i < rdNumArr.Length; i++)
                {
                    rdNumArr[i] = rd.Next(1, 101);
                }
                Console.WriteLine("随机数组元素：");
                ArrayElementDisplay(rdNumArr);
                
                Console.WriteLine("\n数组元素冒泡排序：");
                ArrayElementBubbleSort(rdNumArr);
                
                Console.WriteLine("\n数组元素选择排序：");
                ArrayElementSelectiveSort(rdNumArr);
                
                Console.Write("\n请输入一个数字：");
                int.TryParse(Console.ReadLine(), out int tranTarget);
                int tranResult = tranTarget;
                if (tranResult != 0)
                {
                    Console.WriteLine("\n数组元素插入排序：");
                    int[] insertArr01 = ArrayElementInsertSort(rdNumArr, tranResult);
                    
                    Console.WriteLine("\n使用Array.Reverse(Array array);反转数组元素排列：");
                    Array.Reverse(insertArr01); // 数组元素倒序排列，仅倒序元素，无排序功能
                    ArrayElementDisplay(insertArr01);
                    
                    Console.WriteLine("\n原插入排序数组：");
                    int[] insertArr02 = ArrayElementInsertSort(rdNumArr, tranResult);
                    
                    Console.WriteLine("\n使用数组分割法反转数组元素排列：");
                    ArrayElementSplitInversion(insertArr02);
                }
                else
                {
                    Console.WriteLine("\n提示：数据类型转换失败！");
                }
    
                Console.ReadKey();
            }
    
            /// <summary>
            /// 数组元素分割反转
            /// </summary>
            /// <param name="insertArr"></param>
            private static void ArrayElementSplitInversion(int[] insertArr)
            {
                for (int i = 0; i < insertArr.Length / 2; i++)
                {
                    int temp = insertArr[i];
                    insertArr[i] = insertArr[insertArr.Length - 1 - i];
                    insertArr[insertArr.Length - 1 - i] = temp;
                }
                ArrayElementDisplay(insertArr);
            }
    
            /// <summary>
            /// 数组元素插入排序
            /// </summary>
            /// <param name="rdNumArr"></param>
            /// <param name="tranResult"></param>
            /// <returns></returns>
            private static int[] ArrayElementInsertSort(int[] rdNumArr, int tranResult)
            {
                int[] insertArr = new int[rdNumArr.Length + 1];
                for (int i = 0; i < insertArr.Length; i++)
                {
                    if (i == insertArr.Length - 1)
                    {
                        insertArr[i] = tranResult;
                    }
                    else
                    {
                        insertArr[i] = rdNumArr[i];
                    }
                }
                Array.Sort(insertArr); // 数组元素升序排列，其底层实现是冒泡排序
                ArrayElementDisplay(insertArr);
                return insertArr;
            }
    
            /// <summary>
            /// 数组元素选择排序
            /// </summary>
            /// <param name="rdNumArr"></param>
            private static void ArrayElementSelectiveSort(int[] rdNumArr)
            {
                for (int i = 0; i < rdNumArr.Length - 1; i++)
                {
                    for (int j = i + 1; j < rdNumArr.Length; j++)
                    {
                        if (rdNumArr[i] > rdNumArr[j])
                        {
                            int temp = rdNumArr[i];
                            rdNumArr[i] = rdNumArr[j];
                            rdNumArr[j] = temp;
                        }
                    }
                }
                ArrayElementDisplay(rdNumArr);
            }
    
            /// <summary>
            /// 数组元素冒泡排序
            /// </summary>
            /// <param name="rdNumArr"></param>
            private static void ArrayElementBubbleSort(int[] rdNumArr)
            {
                for (int i = 0; i < rdNumArr.Length - 1; i++)
                {
                    for (int j = 0; j < rdNumArr.Length - 1 - i; j++)
                    {
                        if (rdNumArr[j] > rdNumArr[j + 1])
                        {
                            int temp = rdNumArr[j];
                            rdNumArr[j] = rdNumArr[j + 1];
                            rdNumArr[j + 1] = temp;
                        }
                    }
                }
                ArrayElementDisplay(rdNumArr);
            }
    
            /// <summary>
            /// 数组元素展示
            /// </summary>
            /// <param name="rdNumArr"></param>
            private static void ArrayElementDisplay(int[] rdNumArr)
            {
                for (int i = 0; i < rdNumArr.Length; i++)
                {
                    Console.Write(rdNumArr[i] + "    ");
                }
                Console.WriteLine();
            }
        }
    }
    
    随机数组元素：
    73    31    73    5    78    9    71    23    95    38
    
    数组元素冒泡排序：
    5    9    23    31    38    71    73    73    78    95
    
    数组元素选择排序：
    5    9    23    31    38    71    73    73    78    95
    
    请输入一个数字：16
    
    数组元素插入排序：
    5    9    16    23    31    38    71    73    73    78    95
    
    使用Array.Reverse(Array array);反转数组元素排列：
    95    78    73    73    71    38    31    23    16    9    5
    
    原插入排序数组：
    5    9    16    23    31    38    71    73    73    78    95
    
    使用数组分割法反转数组元素排列：
    95    78    73    73    71    38    31    23    16    9    5

[-]: https://blog.csdn.net/qq_44965393/article/details/107588683