快速排序法与冒泡排序法的核心思想是啥。
百度出来看得我迷糊.我写的这个程序是 冒泡排序法吗？

1.    int[] arr = new int[] { 4, 5, 3, 53, 12, 7, 6, 1 };
   
2. 
   
3.             for (int i = 0; i < arr.Length - 1; i++)
   
4.             {
   
5.                 for (int j = i + 1; j < arr.Length; j++)
   
6.                 {
   
7.                     if (arr[i] > arr[j])
   
8.                     {
   
9.                         int temp;
   
10.                         temp = arr[i];
    
11.                         arr[i] = arr[j];
    
12.                         arr[j] = temp;
    
13.                     }
    
14.                 }
    
15.             }

复制代码

快速排序法是对冒泡排序法的改进哈，你这个是冒泡排序，快速排序啊，字面上看，就是很快，那么很快，就是两分法比较快，所以说嘛，快速排序法把数组分成左右两个部分，然后再比较的。。

你写的是选择排序，是选出最大的数字放在首位然后排后面的元素。
冒泡排序比较的是相邻的两位，第j位和j+1位比较。

楼主写的是冒泡排序  不过这么写太浪费资源了 建议楼主这么写的好

1. int[] arr = new int[] { 4, 5, 3, 53, 12, 7, 6, 1 };
   
2.             bool swapper = true;
   
3.             do
   
4.             {
   
5.                 swapper = false;
   
6.                 for (int i = 0; i < arr.Length - 1; i++)
   
7.                 {
   
8.                     if (arr[i] > arr[i + 1])
   
9.                     {
   
10.                         int temp = arr[i];
    
11.                         arr[i] = arr[i + 1];
    
12.                         arr[i + 1] = temp;
    
13.                         swapper = true;
    
14.                     }
    
15.                 }
    
16.             } while (swapper);

复制代码

选择排序：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完
冒泡排序：它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
快速排序：是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数组成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序。
很明显楼主你的代码每一趟都从数组中选出了一个最小值放在数组开头位置，不是通过比较相邻两个元素的方式完成的，也没有将数组分割成两部分无序数组，所以是选择排序。

这个是典型的冒泡排序

1. int[] numbers = { 1, 3, 5, 6, 9, 8, 2, 7, 4 };
   
2.             
   
3.             对数组升序排列
   
4.             for ( int i = 0; i < numbers.Length;i++ )
   
5.             {
   
6.                 for (int j = 0; j < numbers.Length - i-1;j++ )
   
7.                 {
   
8.                     if (numbers[j]>numbers[j+1])
   
9.                     {
   
10.                         int temp = numbers[j];
    
11.                         numbers[j] = numbers[j + 1];
    
12.                         numbers[j + 1] = temp;
    
13.                     }
    
14.                 }
    
15.             }

复制代码

如问题得到解决,请及时修改为"以解决",黑马有你更精彩!

排序方法，思想都不一样 我写的快排
        public static void QuickSort(int[] array, int left, int right)
        {

            if (left < right)
            {

                int middle = GetMiddleFroQuickSort(array, left, right);

                QuickSort(array, left, middle - 1);

                QuickSort(array, middle + 1, right);
            }


        }
        /// <summary>
        /// get the index of the middle value for qucik sort
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <returns></returns>
        private static int GetMiddleFroQuickSort(int[] array, int left, int right)
        {
            int temp = array[left];
            while (left < right)
            {
                while (left < right && array[right]>temp)
                {
                    right--;
                }
                if (left < right)
                {
                    int tm = array[left];
                    array[left] = array[right];
                    array[right] = tm;
                    left++;
                }

                while (left < right && array[left] < temp)
                {
                    left++;
                }
                if (left < right)
                {
                    int tm = array[right];
                    array[right] = array[left];
                    array[left] = temp;
                    right--;
                }
                array[left] = temp;
            }
            return left;
        }

static void Main(string[] args)
        {
            int[] array = new int[] { 12, 5, 8, 20, 97, 3 };
            Quick.QuickSort(array,0,array.Length-1);
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine(array[i]);
            }
            Console.ReadKey();
        }

这是冒泡：
主函数就不写了

public static int[] BubbleSort(int[] args)
        {
            int temp;
            for (int i = 0; i < args.Length - 1; i++)
            {
                for (int j = 0; j < args.Length - i - 1; j++)
                {
                    if (args[j] > args[j + 1])
                    {
                        temp = args[j];
                        args[j] = args[j + 1];
                        args[j + 1] = temp;
                    }
                }
            }
            return args;
        }

快速排序对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的
两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分
数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

冒泡排序的思想是在每一次排序过程，通过相邻元素的交换，将当前没有排好序中的最大（小）移到数组的最右（左）端。而选择排序的思想也很直观：每一次排序过程，我们获取当前没有排好序中的最大（小）的元素和数组最右（左）端的元素交换，循环这个过程即可实现对整个数组排序，其算法的时间复杂度为O（N＾2）
而快速排序使用的是分治的思想，先选定一个值，再将比这个值小的元素放在它的左（右）边，将比它大的放在另一边；然后在左边的元素中再找一个值，重复上面的操作；在右边也进行相同的操作，最后整个数组就会被排好顺序了，这个算法的时间复杂度为O（NLOGN），但是很不稳定

这个怎么会是冒泡排序，，，晕死、、、