用Python实现十大经典排序算法(附动图)

news2024/9/26 8:32:46

排序算法是《数据结构与算法》中最基本的算法之一。

排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括：

关于时间复杂度

  1. 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。

  2. 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序；

  3. O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。希尔排序

  4. 线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。

关于稳定性

  • 排序后 2 个相等键值的顺序和排序之前它们的顺序相同

  • 稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。

  • 不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

名词解释

  • n：数据规模

  • k：“桶”的个数

  • In-place：占用常数内存，不占用额外内存

  • Out-place：占用额外内存

1、冒泡排序

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来说并没有什么太大作用。

（1）算法步骤

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

  3. 针对所有的元素重复以上的步骤，除了最后一个。

  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

（2）动图演示

（3）Python 代码

def bubbleSort(arr):
    for i in range(1, len(arr)):
        for j in range(0, len(arr)-i):
            if arr[j] > arr[j+1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

2、选择排序

选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

（1）算法步骤

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

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

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

（2）动图演示

（3）Python 代码

def selectionSort(arr):
    for i in range(len(arr) - 1):
        # 记录最小数的索引
        minIndex = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[minIndex]:
                minIndex = j
        # i 不是最小数时，将 i 和最小数进行交换
        if i != minIndex:
            arr[i], arr[minIndex] = arr[minIndex], arr[i]
    return arr

3、插入排序

插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。

（1）算法步骤

  1. 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

  2. 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

（2）动图演示

（3）Python 代码

def insertionSort(arr):
    for i in range(len(arr)):
        preIndex = i-1
        current = arr[i]
        while preIndex >= 0 and arr[preIndex] > current:
            arr[preIndex+1] = arr[preIndex]
            preIndex-=1
        arr[preIndex+1] = current
    return arr

4、希尔排序

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

  • 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；

  • 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；

希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

（1）算法步骤

  1. 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；

  2. 按增量序列个数 k，对序列进行 k 趟排序；

  3. 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

（2）Python 代码

def shellSort(arr):
    import math
    gap=1
    while(gap < len(arr)/3):
        gap = gap*3+1
    while gap > 0:
        for i in range(gap,len(arr)):
            temp = arr[i]
            j = i-gap
            while j >=0 and arr[j] > temp:
                arr[j+gap]=arr[j]
                j-=gap
            arr[j+gap] = temp
        gap = math.floor(gap/3)
    return arr

5、归并排序

归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：

  • 自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；

  • 自下而上的迭代；

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间。

（1）算法步骤

  1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

  2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置；

  3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

  4. 重复步骤 3 直到某一指针达到序列尾；

  5. 将另一序列剩下的所有元素直接复制到合并序列尾。

（2）动图演示

（3）Python 代码

def mergeSort(arr):
    import math
    if(len(arr)<2):
        return arr
    middle = math.floor(len(arr)/2)
    left, right = arr[0:middle], arr[middle:]
    return merge(mergeSort(left), mergeSort(right))

def merge(left,right):
    result = []
    while left and right:
        if left[0] <= right[0]:
            result.append(left.pop(0));
        else:
            result.append(right.pop(0));
    while left:
        result.append(left.pop(0));
    while right:
        result.append(right.pop(0));
    return result

6、快速排序

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。

快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。

快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高！它是处理大数据最快的排序算法之一了。虽然 Worst Case 的时间复杂度达到了 O(n²)，但是人家就是优秀，在大多数情况下都比平均时间复杂度为 O(n logn) 的排序算法表现要更好，可是这是为什么呢，我也不知道。好在我的强迫症又犯了，查了 N 多资料终于在《算法艺术与信息学竞赛》上找到了满意的答案：

快速排序的最坏运行情况是 O(n²)，比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn)，且 O(nlogn) 记号中隐含的常数因子很小，比复杂度稳定等于 O(nlogn) 的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。

（1）算法步骤

① 从数列中挑出一个元素，称为 “基准”（pivot）;

② 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

③ 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

（2）动图演示

（3）Python 代码

def quickSort(arr, left=None, right=None):
    left = 0 if not isinstance(left,(int, float)) else left
    right = len(arr)-1 if not isinstance(right,(int, float)) else right
    if left < right:
        partitionIndex = partition(arr, left, right)
        quickSort(arr, left, partitionIndex-1)
        quickSort(arr, partitionIndex+1, right)
    return arr

def partition(arr, left, right):
    pivot = left
    index = pivot+1
    i = index
    while  i <= right:
        if arr[i] < arr[pivot]:
            swap(arr, i, index)
            index+=1
        i+=1
    swap(arr,pivot,index-1)
    return index-1

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

7、堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：

  1. 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；

  2. 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；

堆排序的平均时间复杂度为 Ο(nlogn)。

（1）算法步骤

  1. 创建一个堆 H[0……n-1]；

  2. 把堆首（最大值）和堆尾互换；

  3. 把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；

  4. 重复步骤 2，直到堆的尺寸为 1。

（2）动图演示

（3）Python 代码

def buildMaxHeap(arr):
    import math
    for i in range(math.floor(len(arr)/2),-1,-1):
        heapify(arr,i)

def heapify(arr, i):
    left = 2*i+1
    right = 2*i+2
    largest = i
    if left < arrLen and arr[left] > arr[largest]:
        largest = left
    if right < arrLen and arr[right] > arr[largest]:
        largest = right

    if largest != i:
        swap(arr, i, largest)
        heapify(arr, largest)

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

def heapSort(arr):
    global arrLen
    arrLen = len(arr)
    buildMaxHeap(arr)
    for i in range(len(arr)-1,0,-1):
        swap(arr,0,i)
        arrLen -=1
        heapify(arr, 0)
    return arr

8、计数排序

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

（1）动图演示

（2）Python 代码

def countingSort(arr, maxValue):
    bucketLen = maxValue+1
    bucket = [0]*bucketLen
    sortedIndex =0
    arrLen = len(arr)
    for i in range(arrLen):
        if not bucket[arr[i]]:
            bucket[arr[i]]=0
        bucket[arr[i]]+=1
    for j in range(bucketLen):
        while bucket[j]>0:
            arr[sortedIndex] = j
            sortedIndex+=1
            bucket[j]-=1
    return arr

9、桶排序

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：

  1. 在额外空间充足的情况下，尽量增大桶的数量

  2. 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中

同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要。

什么时候最快

当输入的数据可以均匀的分配到每一个桶中。

什么时候最慢

当输入的数据被分配到了同一个桶中。

Python 代码

def bucket_sort(s):
    """桶排序"""
    min_num = min(s)
    max_num = max(s)
    # 桶的大小
    bucket_range = (max_num-min_num) / len(s)
    # 桶数组
    count_list = [ [] for i in range(len(s) + 1)]
    # 向桶数组填数
    for i in s:
        count_list[int((i-min_num)//bucket_range)].append(i)
    s.clear()
    # 回填，这里桶内部排序直接调用了sorted
    for i in count_list:
        for j in sorted(i):
            s.append(j)

if __name__ == __main__ :
    a = [3.2,6,8,4,2,6,7,3]
    bucket_sort(a)
    print(a) # [2, 3, 3.2, 4, 6, 6, 7, 8]

10、基数排序

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

基数排序 vs 计数排序 vs 桶排序

基数排序有两种方法：

这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：

  • 基数排序：根据键值的每位数字来分配桶；

  • 计数排序：每个桶只存储单一键值；

  • 桶排序：每个桶存储一定范围的数值；

动图演示

Python 代码

def RadixSort(list):
    i = 0                                    #初始为个位排序
    n = 1                                     #最小的位数置为1（包含0）
    max_num = max(list) #得到带排序数组中最大数
    while max_num > 10**n: #得到最大数是几位数
        n += 1
    while i < n:
        bucket = {} #用字典构建桶
        for x in range(10):
            bucket.setdefault(x, []) #将每个桶置空
        for x in list: #对每一位进行排序
            radix =int((x / (10**i)) % 10) #得到每位的基数
            bucket[radix].append(x) #将对应的数组元素加入到相 #应位基数的桶中
        j = 0
        for k in range(10):
            if len(bucket[k]) != 0: #若桶不为空
                for y in bucket[k]: #将该桶中每个元素
                    list[j] = y #放回到数组中
                    j += 1
        i += 1
return  list

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/150960.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

69、CLIP-NeRF: Text-and-Image Driven Manipulation of Neural Radiance Fields

69、CLIP-NeRF: Text-and-Image Driven Manipulation of Neural Radiance Fields

简介 官网&#xff1a;https://cassiepython.github.io/clipnerf/ 利用对比语言-图像预训练(CLIP)模型的联合语言-图像嵌入空间&#xff0c;提出了一个统一的框架&#xff0c;可以用短文本提示或示例图像以用户友好的方式操纵NeRF。改论文结合NeRF的新视图合成能力和生成模型潜…
阅读更多...
【自学Python】Python缩进规则

【自学Python】Python缩进规则

Python缩进规则 Python缩进规则教程 Python 和其它程序设计语言采用大括号 {} 分隔代码块不同&#xff0c;Python 采用代码缩进和冒号来区分代码块之间的层次。 在 Python 中&#xff0c;对于 类定义、函数定义、流程控制语句、异常处理语句 等&#xff0c;行尾的冒号和下一…
阅读更多...
【Linux篇】之TFTP服务配置

【Linux篇】之TFTP服务配置

tftp是基于UDP协议的简单文本文件传输协议&#xff1b; 用途&#xff1a;使用网络的方式将文件传输(下载)到开发板中。 具体的tftp服务的安装步骤&#xff1a; 1> 安装tftp服务 (ubuntu必须可以上网) sudo apt-get update ----> 更新源 sudo apt-get install tftpd-hpa…
阅读更多...
【MyBatis】如何使用“动态SQL”（不用找了，这一篇足矣）

【MyBatis】如何使用“动态SQL”（不用找了，这一篇足矣）

目录 一、if标签 二、where标签 三、trim标签 四、choose、when、otherwise 五、foreach标签 六、sql标签 一、if标签 if&#xff0c;通过test属性中的表达式判断标签中的内容是否有效&#xff08;有效才将if里面的内容拼接到sql中&#xff09;&#xff1b;一般用于用户在…
阅读更多...
Authing 通过中国信通院「身份治理系统和工具能力」全面级评估

Authing 通过中国信通院「身份治理系统和工具能力」全面级评估

Authing 通过中国信通院「身份治理系统和工具能力」全面级评估 近期&#xff0c;Authing 荣获由中国信通院颁发的「身份治理系统和工具能力」全面级评估。在统一身份管理、统一认证管理、开发集成管理以及统一安全管理四个模块满足身份治理系统和工具支撑能力全面级要求。 评估…
阅读更多...
Java--main()方法

Java--main()方法

文章目录一、main()方法使用二、mian()方法调用一、main()方法使用 1、访问控制权限是公有的&#xff08;public&#xff09; 2、main() 方法是静态的。如果要在 main() 方法中调用本类中的其他方法&#xff0c;则该方法也必须是静态的&#xff0c;否则需要先创建本类的实例对…
阅读更多...
进程间通信【共享内存】

进程间通信【共享内存】

共享内存共享内存共享内存原理创建共享内存关联共享内存去关联共享内存控制共享内存使用共享内存代码共享内存 进程间通信的前提是&#xff1a;先让不同的进程&#xff0c;看到同一份资源 之前&#xff0c;管道进程通信是采用看到同一个文件&#xff0c;那么共享内存就是看到同…
阅读更多...
审查 Git 仓库的绝佳工具Tig

审查 Git 仓库的绝佳工具Tig

简介 Tig 是一个 基于 ncurses 的 Git 文本模式界面&#xff0c;它允许你浏览 Git 仓库中的更改。它还可以充当各种 Git 命令输出的分页器。使用这个工具可以让我很好地了解在哪个提交中发生了哪些更改&#xff0c;最新的提交合并是什么等等。 git工作原理&#xff1a;https:…
阅读更多...
黑马学ElasticSearch（三）

黑马学ElasticSearch（三）

目录&#xff1a; &#xff08;1&#xff09;RestClient-操作索引库-导入demo &#xff08;2&#xff09;RestClient操作索引-hotel数据结构分析 &#xff08;3&#xff09;RestClient操作索引库-初始化RestClient &#xff08;4&#xff09;RestClient操作索引库-创建索引库…
阅读更多...
如何掌握TikTok广告投放技巧，玩转“TikTok+独立站”新模式？

如何掌握TikTok广告投放技巧，玩转“TikTok+独立站”新模式？

导读&#xff1a;TikTok已经发展成为全球第六大社交媒体网络&#xff0c;这使其成为一个非常富饶的广告目的地。 跨境卖家如何在 TikTok 上投放广告&#xff1f;在“TikTok独立站”模式中&#xff0c;卖家在 TikTok ads 上投放电商广告&#xff0c;用户点击后将跳转到独立站落地…
阅读更多...
21. 合并两个有序链表(链表)

21. 合并两个有序链表(链表)

文章目录题目方法一 暴力法:创建头结点,比较拼接方法二 递归法参考文献题目 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,…
阅读更多...
【从零开始学习深度学习】42. 算法优化之AdaDelta算法【基于AdaGrad算法的改进】介绍及其Pytorch实现

【从零开始学习深度学习】42. 算法优化之AdaDelta算法【基于AdaGrad算法的改进】介绍及其Pytorch实现

除了上一篇文章介绍的RMSProp算法以外&#xff0c;另一个常用优化算法AdaDelta算法也针对AdaGrad算法在迭代后期可能较难找到有用解的问题做了改进 。比较有意思的是&#xff0c;AdaDelta算法没有学习率这一超参数。 目录1. AdaDelta算法介绍2. 从零实现AdaDelta算法3. Pytorch…
阅读更多...
UDS诊断系列介绍04-10会话服务

UDS诊断系列介绍04-10会话服务

本文框架1. 系列介绍10服务概述2. 10服务请求与应答2.1 10服务请求2.2 肯定应答2.3 否定应答1. 系列介绍 UDS&#xff08;Unified Diagnostic Services&#xff09;协议&#xff0c;即统一的诊断服务&#xff0c;是面向整车所有ECU的一种诊断通信方式&#xff0c;是基于ISO 14…
阅读更多...
Linux学习笔记——集群化环境前置准备

Linux学习笔记——集群化环境前置准备

5.7、集群化环境前置准备 5.7.1、介绍 在前面&#xff0c;我们所学习安装的软件&#xff0c;都是以单机模式运行的。 后续&#xff0c;我们将要学习大数据相关的软件部署&#xff0c;所以后续我们所安装的软件服务&#xff0c;大多数都是以集群化&#xff08;多台服务器共同…
阅读更多...
使用OpenCV读取视频、图片并做简单处理

使用OpenCV读取视频、图片并做简单处理

1.OpenCV的安装与卸载 在conda中安装opencv&#xff0c;打开Anaconda Prompt 使用国内镜像源安装opencv&#xff0c;命令如下&#xff1a; pip install opencv-python -i https://pypi.tuna.tsinghua.edu.cn/simple 也可以安装opencv的另一个扩展包opencv-contrib-python&am…
阅读更多...
Centos下使用yum安装Mysql8（Mysql5.7）以及常见的配置和使用

Centos下使用yum安装Mysql8（Mysql5.7）以及常见的配置和使用

记录一下在centos7.x下面使用yum方式安装mysql8(Mysql5.7)关系型数据库安装之前一般需要先确定centos7.x服务器里是否已经安装&#xff0c;未安装或者刚初始化的centos7.x服务器最好安装&#xff0c;原来已经有的要升级的话一定要对系统原有mysql 或mariadb卸载干净&#xff0c…
阅读更多...
系统测试的具体测试类型

系统测试的具体测试类型

系统测试&#xff1a;是为判断系统是否符合要求而对集成的软、硬件系统进行的测试活动、它是将已经集成好的软件系统&#xff0c;作为基于整个计算机系统的一个元素&#xff0c;与计算机硬件、外设、某些支持软件、人员、数据等其他系统元素结合在一起&#xff0c;在实际运行环…
阅读更多...
Charles - 夜神模拟器证书安装App抓包

Charles - 夜神模拟器证书安装App抓包

Charles - 夜神模拟器证书安装App抓包 文章目录Charles - 夜神模拟器证书安装App抓包前言一、软件安装1.Openssl安装1.1下载安装1.2配置环境变量1.3查看openssl版本&#xff0c;输入命令&#xff1a;openssl version2.夜神模拟器安装1.1 下载安装1.2工具准备&#xff0c;MT管理…
阅读更多...
【Lilishop商城】No4-6.业务逻辑的代码开发，涉及到：接口入参、出参开发逻辑，及POJO的各种总结

【Lilishop商城】No4-6.业务逻辑的代码开发，涉及到：接口入参、出参开发逻辑，及POJO的各种总结

仅涉及后端&#xff0c;全部目录看顶部专栏&#xff0c;代码、文档、接口路径在&#xff1a; 【Lilishop商城】记录一下B2B2C商城系统学习笔记~_清晨敲代码的博客-CSDN博客 全篇会结合业务介绍重点设计逻辑&#xff0c;其中重点包括接口类、业务类&#xff0c;具体的结合源代…
阅读更多...
完整iOS APP发布App Store上架流程指南

完整iOS APP发布App Store上架流程指南

本文章的目的在于教会你如何创建ios的打包证书和如何上架假如你没有任何的打包或上架经验&#xff0c;参考本文有很大的收益。通常创建ios证书和上架&#xff0c;是需要MAC电脑的&#xff0c;本文重点介绍如何在没有mac电脑的情况下&#xff0c;创建mac证书和上架。假如你还没有…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023