A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 李小熊 中级黑马   /  2013-10-26 09:47  /  3156 人查看  /  11 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 李小熊 于 2013-10-27 10:30 编辑

快速排序法与冒泡排序法的核心思想是啥。
百度出来看得我迷糊.我写的这个程序是 冒泡排序法吗?
  1.    int[] arr = new int[] { 4, 5, 3, 53, 12, 7, 6, 1 };

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

评分

参与人数 1技术分 +1 收起 理由
陈行 + 1

查看全部评分

11 个回复

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

评分

参与人数 1技术分 +1 收起 理由
茹化肖 + 1

查看全部评分

回复 使用道具 举报
你写的是选择排序,是选出最大的数字放在首位然后排后面的元素。
冒泡排序比较的是相邻的两位,第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技术分 +1 收起 理由
追溯客 + 1

查看全部评分

回复 使用道具 举报
本帖最后由 宋清飞 于 2013-10-26 17:01 编辑

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

评分

参与人数 1技术分 +1 收起 理由
追溯客 + 1

查看全部评分

回复 使用道具 举报
这个是典型的冒泡排序
  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.             }
复制代码

评分

参与人数 1技术分 +1 收起 理由
追溯客 + 1

查看全部评分

回复 使用道具 举报
如问题得到解决,请及时修改为"以解决",黑马有你更精彩!
回复 使用道具 举报
排序方法,思想都不一样 我写的快排
        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),但是很不稳定
回复 使用道具 举报
这个怎么会是冒泡排序,,,晕死、、、
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马