精华内容
下载资源
问答
  • 堆排序过程、时间复杂度及空间复杂度? 写出你所知道排序算法及时空复杂度,稳定性? 快速排序 算法数组选择一个称为...最差情况下,划分由 n 个元素构成数组需要进行 n 次比较和 n 次移动。因此划分所...

    堆排序过程、时间复杂度及空间复杂度?
    写出你所知道的排序算法及时空复杂度,稳定性?在这里插入图片描述

    快速排序

    算法在数组中选择一个称为主元(pivot)的元素,将数组分为两部分,使得 第一部分中的所有元素都小于或等于主元,而第二部分的所有元素都大于主元。对第一部分递归地应用快速排序算法,然后对第二部分递归地应用快速排序算法。
    在最差情况下,划分由 n 个元素构成的数组需要进行 n 次比较和 n 次移动。因此划分所需时间为 O(n) 。最差情况下,每次主元会将数组划分为一个大的子数组和一个空数组。这个大的子数组的规模是在上次划分的子数组的规模减 1 。该算法需要 (n-1)+(n-2)+…+2+1= O(n^2) 时间。
    在最佳情况下,每次主元将数组划分为规模大致相等的两部分。设 T(n) 表示使用快速排序算法对包含 n 个元素的数组排序所需的时间,因此,和归并排序的分析相似,快速排序的 T(n)= O(nlogn)。

    快速排序,⼜称划分交换排序

    1.通过⼀趟排序将要排序的数据分割成独⽴的两部分,
    其中⼀部分的所有数据都⽐另外⼀部分的所有数据都要⼩
    2.然后再按此⽅法对这两部分数据分别进⾏快速排序,整个排序过程可以递归进⾏,以此达到整个数据变成有序序列。

    步骤为:

    1. 从数列中挑出⼀个元素,称为"基准"(pivot)
    2. 重新排序数列,所有元素⽐基准值⼩的摆放在基准前⾯,所有元素⽐基准值⼤的摆在基准的后⾯(相同的数可以到任⼀边)。
    3. 在这个分区结束之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。
    4. 递归地(recursive)把⼩于基准值元素的⼦数列和⼤于基准值元素的⼦
      数列排序。
      递归的最底部情形,是数列的⼤⼩是零或⼀,也就是永远都已经被排序好了。虽然⼀直递归下去,但是这个算法总会结束,因为在每次的迭代(iteration)中,它⾄少会把⼀个元素摆到它最后的位置去。
    def quick_sort(list1, start, end):
        # 递归的退出条件
        if start >= end:
            return
        # 设置起始元素为要寻找位置的基准元素
        mid = list1[start]
        # left为序列左边的由左向右移动的游标
        left = start
        # right为序列右边的由右向左移动的游标
        right = end
        while left < right:
            # 如果left和right未重合,right指向的元素不比基准元素小,
            # 则right向左移动
            while left < right and list1[right] >= mid:
                right -= 1
            # 将right指向的元素放到left的位置上
            list1[left] = list1[right]
            # 如果left于right未重合,left指向的元素比基准元素小
            # 则left向右移动
            while left < right and list1[left] < mid:
                left += 1
            # 将left指向的元素放到right的位置上
            list1[right] = list1[left]
    
        # 退出循环后,left与right重合,此时所指位置为基准元素的正确位置
        # 将基准元素放到该位置
        list1[left] = mid
        # 对基准元素左边的子序列进行快速排序
        quick_sort(list1, start, left-1)
        # 对基准元素右边的子序列进行快速排序
        quick_sort(list1, left+1, end)
    
    li = [23, 94, 2, 21, 56, 6]
    quick_sort(li, 0, len(li)-1)
    print(li)
    
    

    在这里插入图片描述

    冒泡排序

    是⼀种简单的排序算法。

    它重复地遍历要排序的数列,⼀次⽐较两个元素,如果他们的顺序错误就把他们交换过来。

    遍历数列的⼯作是重复地进⾏直到没有再需要交换,也就是说该数列已经排序完成。

    这个算法的名字由来是因为越⼩的元素会经由交换慢慢“浮”到数列的
    顶端

    冒泡排序算法的运作如下:
    1.⽐较相邻的元素。如果第⼀个⽐第⼆个⼤(升序),就交换他们两个。
    2.对每⼀对相邻元素作同样的⼯作,从开始第⼀对到结尾的最后⼀对。这步做完后,最后的元素会是最⼤的数。
    3.针对所有的元素重复以上的步骤,除了最后⼀个。
    4.持续每次对越来越少的元素重复上⾯的步骤,直到没有任何⼀对数字需要⽐较

    代码实现:

    def bubble_sort(list1):
        n = len(list1)
        # j 控制每次遍历需要比较的次数
        for j in range(n-1):
            count = 0
            # 通过i 表示每次需要比较的数字
            for i in range(0, n-1-j):
                if list1[i] > list1[i + 1]:
                    list1[i], list1[i + 1] = list1[i + 1], list1[i]
                    count += 1
            if 0 == count:
                break
    
    li = [23, 94, 2, 21, 56, 6]
    bubble_sort(li)
    print(li)
    
    

    归并排序python实现

    归并排序在于把序列拆分再合并起来,使用分治法来实现,这就意味这要构造递归算法

    首先是一个例子

    在这里插入图片描述
    原序先通过一半一半的拆分,然后:

    在这里插入图片描述

    然后再一步一步的向上合并,在合并的过程中完成了排序,合并排序算法如下

    
    def merge(s1,s2,s):
        """将两个列表是s1,s2按顺序融合为一个列表s,s为原列表"""
        # j和i就相当于两个指向的位置,i指s1,j指s2
        i = j = 0
        while i+j<len(s):
            # j==len(s2)时说明s2走完了,或者s1没走完并且s1中该位置是最小的
            if j==len(s2) or (i<len(s1) and s1[i]<s2[j]):
                s[i+j] = s1[i]
                i += 1
            else:
                s[i+j] = s2[j]
                j += 1
    
    

    这是以列表为例,道理其实很简单,因为两个序列是排好序的,所以都从左往右,互相比较选择较小的那个数放入最后的序列,s是原序列,所以在一开始会有与len(s)的比较

    完整算法
    算法中通过递归并调用merge函数完成排序

    
    def merge(s1,s2,s):
        """将两个列表是s1,s2按顺序融合为一个列表s,s为原列表"""
        # j和i就相当于两个指向的位置,i指s1,j指s2
        i = j = 0
        while i+j<len(s):
            # j==len(s2)时说明s2走完了,或者s1没走完并且s1中该位置是最小的
            if j==len(s2) or (i<len(s1) and s1[i]<s2[j]):
                s[i+j] = s1[i]
                i += 1
            else:
                s[i+j] = s2[j]
                j += 1
    
    def merge_sort(s):
        """归并排序"""
        n = len(s)
        # 剩一个或没有直接返回,不用排序
        if n < 2:
            return
        # 拆分
        mid = n // 2
        s1 = s[0:mid]
        s2 = s[mid:n]
        # 子序列递归调用排序
        merge_sort(s1)
        merge_sort(s2)
        # 合并
        merge(s1,s2,s)
    
    
    if __name__ == '__main__':
        s = [1,7,3,5,4]
        merge_sort(s)
        print(s)
    
    

    时间复杂度
    这个图显然是二叉树的形式,所以若集合有n个元素,那高度就为log(n)

    但其实在每一层做比较的时候,都是一个一个的向序列中放小的元素,每一层都是要放n次

    所以时间复杂度为nlog(n)

    基数排序python实现

    基数排序python实现
    基数排序
    基数排序(英语:Radix sort)是一种非比较型整数排序算法,其原理是将整数按位数切割成不同的数字,然后按每个位数分别比较。由于整数也可以表达字符串(比如名字或日期)和特定格式的浮点数,所以基数排序也不是只能使用于整数。

    所以基数排序的原理就是,先排元素的最后一位,再排倒数第二位,直到所有位数都排完。这里并不能先排第一位,那样最后依然是无序。

    举个例子:

    第一次排最低位,上边的序列变成了下面的样子

    从这个图中也能看出,排序是基于桶排序实现的。

    然后就像排最低位一样,然后再排倒数第二位,再排倒数第三位。注意向桶中放元素的时候一定要按顺序放。

    具体代码
    这里将列表进行基数排序,默认列表中的元素都是正整数

     
    def radix_sort(s):
        """基数排序"""
        i = 0 # 记录当前正在排拿一位,最低位为1
        max_num = max(s)  # 最大值
        j = len(str(max_num))  # 记录最大值的位数
        while i < j:
            bucket_list =[[] for _ in range(10)] #初始化桶数组
            for x in s:
                bucket_list[int(x / (10**i)) % 10].append(x) # 找到位置放入桶数组
            print(bucket_list)
            s.clear()
            for x in bucket_list:   # 放回原序列
                for y in x:
                    s.append(y)
            i += 1
     
    if __name__ == '__main__':
        a = [334,5,67,345,7,345345,99,4,23,78,45,1,3453,23424]
        radix_sort(a)
        print(a)
    

    希尔排序算法描述

    简单插入排序很循规蹈矩,不管数组分布是怎么样的,依然一步一步的对元素进行比较,移动,插入,比如[5,4,3,2,1,0]这种倒序序列,数组末端的0要回到首位置很是费劲,比较和移动元素均需n-1次。而希尔排序在数组中采用跳跃式分组的策略,通过某个增量将数组元素划分为若干组,然后分组进行插入排序,随后逐步缩小增量,继续按组进行插入排序操作,直至增量为1。希尔排序通过这种策略使得整个数组在初始阶段达到从宏观上看基本有序,小的基本在前,大的基本在后。然后缩小增量,到增量为1时,其实多数情况下只需微调即可,不会涉及过多的数据移动。

    希尔排序首先选择一个元素选择步长将数组划分为若干小组,对各个小组分别进行排序,然后不断将步长缩小,不断分组和排序,直到后的步长为1,对所有的元素进行排序,此时,经过前期的排序工作,能够减少全体元素插入排序的对比次数,大大降低了排序的时间复杂度。

    我们来看下希尔排序的基本步骤,在此我们选择增量gap=length/2,缩小增量继续以gap = gap/2的方式,这种增量选择我们可以用一个序列来表示,{n/2,(n/2)/2…1},称为增量序列。希尔排序的增量序列的选择与证明是个数学难题,我们选择的这个增量序列是比较常用的,也是希尔建议的增量,称为希尔增量。

    以一个实际的例子说明希尔排序的执行过程:

    将数组{13,7,3,8,12,510,2}从小到大进行排序。

    第一次分组排序:选择步长8/2=4,图下方的数组表示分组情况

    在这里插入图片描述

    第二次排序:选择步长4/2=2;
    在这里插入图片描述
    在这里插入图片描述

    第三次分组排序:选择步长2/2=1;
    在这里插入图片描述

    在这里插入图片描述

    二、算法分析

    不需要大量的辅助空间,和归并排序一样容易实现。希尔排序是基于插入排序的一种算法, 在此算法基础之上增加了一个新的特性,提高了效率。希尔排序的时间复杂度与增量序列的选取有关,例如希尔增量时间复杂度为O(n²),而Hibbard增量的希尔排序的时间复杂度为O(),希尔排序时间复杂度的下界是n*log2n。希尔排序没有快速排序算法快 O(n(logn)),因此中等大小规模表现良好,对规模非常大的数据排序不是最优选择。但是比O()复杂度的算法快得多。并且希尔排序非常容易实现,算法代码短而简单。 此外,希尔算法在最坏的情况下和平均情况下执行效率相差不是很多,与此同时快速排序在最坏的情况下执行的效率会非常差。专家们提倡,几乎任何排序工作在开始时都可以用希尔排序,若在实际使用中证明它不够快,再改成快速排序这样更高级的排序算法. 本质上讲,希尔排序算法是直接插入排序算法的一种改进,减少了其复制的次数,速度要快很多。 原因是,当n值很大时数据项每一趟排序需要移动的个数很少,但数据项的距离很长。当n值减小时每一趟需要移动的数据增多,此时已经接近于它们排序后的最终位置。 正是这两种情况的结合才使希尔排序效率比插入排序高很多。Shell算法的性能与所选取的分组长度序列有很大关系。只对特定的待排序记录序列,可以准确地估算关键词的比较次数和对象移动次数。

    时间复杂度:

    在最优的情况下,时间复杂度为:O(n ^ (1.3) ) (元素已经排序好顺序)

    在最差的情况下,时间复杂度为:O(n ^ 2);

    空间复杂度:

    O(1)

    由于多次插入排序,我们知道一次插入排序是稳定的,不会改变相同元素的相对顺序,但在不同的插入排序过程中,相同的元素可能在各自的插入排序中移动,最后其稳定性就会被打乱,所以shell排序是不稳定的。

    a=[3,4,1,5,2,9,7,8,6,10,11]
    print("排序前:"+str(a))
    alen=int(len(a))
    def shellsort(a):
        n=alen
        while(n>0):
            n=n//2
            for i in range(n):
                for j in range(i,alen,n):
                    temp=a[j]
                    if(temp<a[j-n]):
                        while((temp<a[j-n]) and j>0):
                            a[j]=a[j-n]
                            j=j-n
                        a[j]=temp
    shellsort(a)
    print("排序后:"+str(a))
    
    展开全文
  • 快速排序冒泡排序的一种改进,其基本思想是基于分治法的:待排序表L[1...n]任取一个元素p作为基准 通过一趟排序将待排序的表L划分为两部分L[1...k-1]和L[k+1...n],使得L[1...k-1]的所有元素小于p,L[k+1...

    什么是“快速排序”?

    快速排序是对冒泡排序的一种改进,其基本思想是基于分治法的:在待排序表L[1...n]中任取一个元素p作为基准

    通过一趟排序将待排序的表L划分为两部分L[1...k-1]和L[k+1...n],使得L[1...k-1]中的所有元素小于p,L[k+1...n]中的所有元素大于等于p,而p放在了其最终位置L[k]上,这个过程称为一趟快速排序。

    而后递归地分别对两个子表重复上述过程,直至每部分内只有一个元素或空为止,即所有元素放在了其最终位置上。

    具体的程序结构:

    int Partition(ElemType A[],int low,int high){
    
        ElemType pivot=A[low];//当前表的第一个元素设为中枢值
        while(low<high){
            while(low<high&&A[high]>=pivot) --high;
            A[low]=A[high];//比中枢值小则移到左端
            while(low<high&&A[low]<pivot) low++;
            A[high]=A[low];//比中枢值大则移到右端
        }
        A[low]=pivot;
        return low;
    
    }
    
    void QuickSort(ElemType A[],int low,int high){
        if(low<high){
        int pivotpos=Partition(A,low,high);
        QuickSort(A,low,pivotpos-1);
        QuickSort(A,pivotpos+1,high);
        }
    }

     

    展开全文
  • 文章目录希尔排序归并排序快速排序(20世纪世界影响最大的算法之一)牛掰!堆排序 希尔排序 排序思想:希尔排序可以说是插入排序的一种变种。无论是插入排序还是冒泡排序,如果数组的最大值刚好是第一位,要将它...
  • 快速排序

    2020-12-16 16:25:24
    其基本思想是:排序的n个元素中任取一个(通常取第一个)作为基准(pivot),把该元素放到适当的位置,数据序列被此元素划分为两部分。比该元素小的放在前一部分,大的放在后一部分,这样基准元素就被放在了适当的...

    007 快速排序

    一、算法介绍

    快速排序是由冒泡排序改进而得的。作为目前内排序算法中最快的排序算法,快速排序通常明显比时间效率同为 O(nlogn) 的其他算法更快。其基本思想是:在待排序的n个元素中任取一个(通常取第一个)作为基准(pivot),把该元素放到适当的位置,数据序列被此元素划分为两部分。比该元素小的放在前一部分,大的放在后一部分,这样基准元素就被放在了适当的位置,即归位。然后分别再对划分出的两部分进行同样的操作,直到划分的部分只有一个元素或为空。这一过程中大树一直在往后移,小数一直往前移,所以最终序列一定是有序的。显然,快速排序也用到了分治的策略。因此,快速排序又称分区交换排序。

    二、算法分析

    在分区时,我们可以理解成把在首位置的元素拿出来,然后从后往前找把乱序(比基准小)的数拿出来填进去,再从前往后找把比基准大的数填到刚刚被拿来填空的数留下的空里,一直循环,直到两头碰在一起了,这时就把基准填进去。这样一趟排序就完成了。
    如图所示
    设有一数组a[10],取a[0],38作为基准,将其取出保存到tmp中
    空用黄色标出

    0 1 2 3 4 5 6 7 8 9
    38 24 57 91 16 4 42 20 88 64

    从后往前找,把遇到的第一个小于38的数 即a[7]=20取出填进去

    0 1 2 3 4 5 6 7 8 9
    20 24 57 91 16 4 42 88 64

    从前往后找,把遇到的第一个大于38的数 即a[2]=57取出填入

    0 1 2 3 4 5 6 7 8 9
    20 24 91 16 4 42 57 88 64

    接着从后往前找,把小于38的数 即a[5]=4取出填入

    0 1 2 3 4 5 6 7 8 9
    20 24 4 91 16 42 57 88 64

    接着从前往后找,把大于38的数 即a[3]=91取出填入

    0 1 2 3 4 5 6 7 8 9
    20 24 4 16 91 42 57 88 64

    接着从后往前找,把小于38的数 即a[4]=16取出填入

    0 1 2 3 4 5 6 7 8 9
    20 24 4 16 91 42 57 88 64

    这时,再从前往后找,发现和后面的碰头了,这时就可以把存放在tmp中的a[0]填进去了

    0 1 2 3 4 5 6 7 8 9
    20 24 4 16 38 91 42 57 88 64

    这时我们可以发现38两边的数是满足要求的,第一趟排序就完成了,然后需要对两部分进行相同的操作,直到分出的部分的元素个数为1或0

    三、算法代码

    void QuickSort(int a[], int s, int e) //当前部分头尾位置的索引
    {
        int i=s, j=e;
        int tmp=a[s]; //取出基准
        if(s<e) //元素个数大于1
        {
            while(i<j)
            {
                while(i<j && a[j]>tmp) //从后向前找小于基准的数
                    j--;
                //无须if(i<j),如果因i=j结束循环,a[i] = a[j]也无影响
                a[i] = a[j];
                while(i<j && a[i]<tmp) //从前向后找大于基准的数
                    i++;
                a[j] = a[i];
            }
            a[i] = tmp; //i=j,前后碰头了,就把基准填在碰头的地方
            
            //划分结束,对基准的前后部分再进行相同的操作
            QuickSort(a, s, i-1);
            QuickSort(a, i+1, e);
        }
    }
    

    运行结果
    在这里插入图片描述

    展开全文
  • 对n个元素进行快速排序的过程构成一棵递归树,这样的递归树,每一层最多对n个元素进行划分,所花的时间为O(n)。当初始排序数据随机分布,使每次分成的两个子区间的元素个数大致相等时,递归树高度为log2n,...

            快速排序的时间主要耗费在划分操作上,对长度为n的区间进行划分,共需n-1次关键字的比较,时间复杂度为O(n)。

            对n个元素进行快速排序的过程构成一棵递归树,在这样的递归树中,每一层最多对n个元素进行划分,所花的时间为O(n)。当初始排序数据随机分布,使每次分成的两个子区间中的元素个数大致相等时,递归树高度为log2n,快速排序呈现最好情况,即最好情况下的时间复杂度为O(nlog2n)。快速排序算法的平均时间复杂度也是O(nlog2n)。所以快速排序是一种高效的算法。

    展开全文
  • 交换排序—快速排序

    2019-03-30 15:27:07
    待排序数列任取一个元素(通常是第一个元素作为基准),将所有大于该元素元素放入一边,所有小于该元素元素放入另一边。这一过程叫做一趟快速排序。接着左右两边进行上面重复操作,直到每一个部分内只有一...
  • -暴力解法:考察每一,算法复杂度:O(n^2)归并排序求逆数-归并比较同时,可以依据比较结果,逆序对进行计数-归并排序过程中,第一次排序完成后,分成了两数组 [2368]/[1457] -先2与1进行比较 ...
  • 快速排序实现

    2018-11-27 13:14:07
    在对含有n个元素的数组S一次快速排序过程中,设置low=0,height=n-1,已S[0]为给定值并赋值给t,从height开始向左遍历并且height自减,找到第一个小于t数据元素S[height],然后S[low]=S[height],再从low开始向...
  • 重温经典:快速排序

    2020-05-05 23:14:13
    快速排序(quick sorting)又称为划分排序。快速排序是气泡排序的一种改进,气泡排序进行元素...快速排序的过程可以叙述为:首先从待排序区间(A[0]~A[n-1])选取一个元素(一般选取该区间第一个元素)作...
  • 排序---快速排序

    2017-10-25 21:58:47
    快速排序属于分治策略排序算法。 1.分解:以a[i]为基准元素将a[i:n]划分成...下标q位置划分过程中确定。 2.递归求解:通过递归调用快速排序算法分别a[i,q-1]和a[q+1,n]进行排序。 3.合并:由于a[i,q-1]和a
  • 快速排序算法分析

    2017-05-03 14:46:45
    找出一个元素(理论上可以所有值随便找一个)作为基准,通过一趟排序将要排序的数据分割成独立的两部分,基准左边的数据都小于基准值,右边的部分都大于基准值,然后再按此方法这两部分数据分别进行快速排序,...
  • 快速排序-Quick

    2018-07-30 16:31:56
    快速排序是一种划分交换方法,它采用分治法进行排序。 1.先从数列取出一数作为基准数 2.分区过程,将比基准值大数全放到它右边, 小于或等于它数全放到它左边,基准值则中间 3.再左右区间重复第...
  • 占位方比快排法在对100万数据进行排序时,快了近50倍!!! 占位排序理念是:一是,只对数组全局作一次遍历,以后每次只遍历数组一小部分;二是,把数据迁移次数降至极致。 占位法实现方法是: 分段处理...
  • 本文章主要记录了快速排序算法,算法实现时候固定选择数组最后一个元素值作为主元,对数组进行划分!当然了主元素选取是可以随机来选择以后的的文章会有提到。 算发性能分析 缺点:最坏情况下运行...
  • 一、算法导论上版本 我写第二篇文章,我们已经知道: ...快速排序算法关键是PARTITION过程,它A[p..r]进行就地重排: PARTITION(A, p, r) 1 x ← A[r] //以最后一个元素,A[r]为主元 2...
  • 排序选择题

    万次阅读 2017-05-11 08:28:04
    一、 单项选择题(共71题) 对n个元素的序列进行冒泡排序时,最少的比较次数是( )。...答案:A在对n个元素进行冒泡排序的过程中,第一趟排序至多需要进行( )对相邻元素之间的交换。 A. n B. n
  • 单链表排序

    2017-03-21 20:50:00
    冒泡排序的基本思想就是对于给定的n个元素,从第一个元素开始,依次相邻的两个元素进行比较,当前面的元素大于后面的元素时,交换其位置,进行一轮比较和换位后,n个元素中最大的数将位于第n位,然后前(n-1)...
  • 比较常用的排序算法

    2014-07-01 18:14:50
    7)堆排序:堆排序是一种树形选择排序在排序过程中,将A[n]看成是完全二叉树顺序存储结构,利用完全二叉树中双亲结点和孩子结点之间内在关系来选择最小的元素。 8)基数排序:将所有待比较数值(正整数)...
  • 我们最常用的快速排序和堆排序等算法需要序列中的数据进行比较,因为被称为基于比较排序。 而非基于比较排序有计数排序,桶排序,和此基础上基数排序。要注意是,非基于比较排序算法使用都是有...
  • 冒泡排序的基本思想:从前往后或者从后往前,对相邻的两个元素进行比较,若逆序,则交换。每次冒泡排序都会让至少一个元素移动到它应该的位置,重复n-1,就完成了对n个数据的排序。 如果对一组数据7,8,9,6,5,...
  • 一、 单项选择题(共71题) 1、对n个元素的序列进行冒泡排序时,最少的比较次数是( )。 A....3、在对n个元素进行冒泡排序的过程中,第一趟排序至多需要进行( )对相邻元素之间的交换。 A....
  • 排序的基本概念计算机程序开发过程中,经常需要一组数据元素(或记录)按某个关键字进行排序,排序完成的序列可用于快速查找相关记录。排序概述排序是程序开发中一种非常常见的操作,一组任意的数据元素(或记录)...
  • 冒泡排序

    2010-07-19 18:25:00
    基本思路:一个有n个元素的数列进行排序进行k趟排序,每一趟找出数列最大关键字(最简单交换方式),并将这个最大关键字放在这一趟排序所遍历最后一个位置上。其中要注意是冒泡排序结束条件是...
  • 判断题 1-1对N个记录进行堆排序,需要的额外空间为O(N)(F) 1-2对N个记录进行简单选择排序,比较次数和移动次数分别...2-1在快速排序的一趟划分过程中,当遇到与基准数相等的元素时,如果左右指针都会停止移动,...
  • 基本思想:排序的数组的n个元素中取一个元素(一般取第一个),将其移动到这样的位置:其之前的元素的值都小于它,其之后的元素都大于它,这样是一趟快速排序;然后数组的两个部分进行同样的操作,直到每...
  • 学习了一些常见的排序算法,我这里它们...稳定性:算法实现的过程中是否会改变相同元素的相对位置,不改变则稳定。 1.直接插入排序 主要代码 void InsertSort(int* arr, int n) { for (int i = 0; i < ...

空空如也

空空如也

1 2 3 4 5
收藏数 94
精华内容 37
关键字:

在对n个元素进行快速排序的过程中