基本排序算法的实现

最新推荐文章于 2022-07-30 08:50:01 发布
最新推荐文章于 2022-07-30 08:50:01 发布
阅读量529 收藏 2
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34620855/article/details/108758455
版权

文章目录

前言

  • 数据
    Item[1:len]
    Item[0] -->不存储数据 （功能：哨兵节点OR暂存数据）

内部排序

排序过程在内存中实现

插入排序

查找位置,移动元素,插入

直接插入排序

/**
 * 直接插入排序  顺序存储,链式存储
 * 0:i-1    查找位置 j+1--->顺序查找
 * j+1:i-1  数据移动
 *
 */
void InsertSort(Item *data, int len) {
    int i, j;
    for (i = 2; i < len + 1; i++) {
        data[0] = data[i];
        for (j = i - 1; data[0].value < data[j].value; j--) {
            data[j + 1] = data[j];
        }
        data[j + 1] = data[0];
    }
}

稳定
时间复杂度：O(n2)
空间复杂度：O(1)

最好：有序 O(n)           无查找,移动
最坏：逆序 O(n2)

折半插入排序

/**
 * 折半插入排序  顺序存储
 * 0:i-1    查找位置 j+1--->顺序查找
 * j+1:i-1  数据移动
 *
 */
void BinaryInsertSort(Item *data, int len) {
    int low, high, mid;
    int i, j;
    for (i = 2; i < len + 1; i++) {
        data[0] = data[i];
        low = 1;
        high = i - 1;
        while (low <= high) {
            mid = (low + high) / 2;
            if (data[mid].value > data[0].value)
                high = mid - 1;
            else
                low = mid + 1;
        }


        for (j = i - 1; j >= low; j--)
            data[j + 1] = data[j];

        data[low] = data[0];
        /* data[high + 1] = data[0];*/
    }
}

稳定
时间复杂度：O(n2)
空间复杂度：O(1)

希尔排序

/**
 * 希尔排序(不稳定)  顺序存储
 * 步长选取 d:
 *
 *      d1=n/2    d2=d1/2
 *
 * 最坏O(n^2)   一般O(n^1.3)
 *
 */
void ShellSort(Item *data, int len) {
    int j;
    for (int d = len / 2; d >= 1; d = d / 2) {
        for (int i = d + 1; i <= len; ++i) {
            if (data[i].value < data[i - d].value) {
                data[0] = data[i];//暂存作用,非哨兵

                for (j = i - d; j > 0 && data[0].value < data[j].value; j -= d)
                    data[j + d] = data[j];

                data[j + d] = data[0];
            }
        }
    }
}

不稳定
时间复杂度：O(n2)   O(n1.3）
空间复杂度：O(1)

交换排序

一趟排序过程通过不断的交换,确定其中一个元素的位置

冒泡排序

/**
 * 冒泡排序 顺序存储,链式存储
 * 一趟冒泡一个数据到达最终位置（n-1次冒泡）
 *
 */
void BubbleSort(Item *data, int len) {
    for (int i = 1; i < len; i++) {
        _Bool flag = FALSE;
        for (int j = len; j > i; j--) {
            //查找逆序进行交换
            if (data[j - 1].value > data[j].value) {
                data[0] = data[j];
                data[j] = data[j - 1];
                data[j - 1] = data[0];
                flag = TRUE;
            }
        }

        if (flag == FALSE)
            return;
    }
}

稳定
时间复杂度：O(n2)
空间复杂度：O(1)

最好：有序 O(n)           无查找,移动
最坏：逆序 O(n2)

快速排序

依赖划分,构建二叉树

/**
 * 快速排序 顺序存储,链式存储   不稳定
 * 一次划分过程,一个元素到位
 * Partition 划分
 * QuickSortImpl
 */
void QuickSort(Item *data, int len) {
    QuickSortImpl(data, 1, len);
}

void QuickSortImpl(Item *data, int low, int high) {
    if (low < high) {
        int mid = Partition(data, low, high);
        QuickSortImpl(data, low, mid - 1);
        QuickSortImpl(data, mid + 1, high);
    }
}

int Partition(Item *data, int low, int high) {
    data[0] = data[low];
    while (low < high) {
        while (low < high && data[high].value >= data[0].value)
            high--;
        data[low] = data[high];
        while (low < high && data[low].value <= data[0].value)
            low++;
        data[high] = data[low];
    }
    data[low] = data[0];
    return low;
}

不稳定
时间复杂度：O(nlog2n)
空间复杂度：O(log2n)

最坏：有序,逆序

树的高度max 时间复杂度–> O(n2) 空间复杂度—> O(n)

选择排序

每次选择出当前未排序状态下的最小OR最大

直接选择排序

/**
 * 直接排序 顺序存储,链式存储   不稳定
 * 每次选择一个最小的数据
 */
void SelectSort(Item *data, int len) {
    for (int i = 1; i < len; ++i) {
        int min = i;
        for (int j = i + 1; j <= len; j++) {
            if (data[j].value < data[min].value)
                min = j;
        }

        if (min != i) {
            data[0] = data[i];
            data[i] = data[min];
            data[min] = data[0];
        }
    }
}

不稳定
时间复杂度：O(n2)
空间复杂度：O(1)

堆排序

完全二叉树的顺序存储

/**
 * 堆排序  顺序存储,链式存储 不稳定
 *
 * @param data
 * @param len
 */
void HeapSort(Item *data, int len) {
    BuildMaxHeap(data, len);
    for (int i = len; i > 1; i--) {
        data[0] = data[i];
        data[i] = data[1];
        data[1] = data[0];

        AdjustDown(data, 1, i - 1);
    }
}

void BuildMaxHeap(Item *data, int len) {
    for (int i = len / 2; i > 0; i--) {
        AdjustDown(data, i, len);
    }
}

void AdjustDown(Item *data, int parent, int len) {
    data[0] = data[parent];

    int i;
    for (i = parent * 2; i <= len; i = i * 2) {
        if (i < len && data[i].value < data[i + 1].value)
            i++;
        if (data[0].value >= data[i].value)
            break;
        else {
            data[parent] = data[i];
            parent = i;
        }
    }
    data[parent] = data[0];
}

不稳定
时间复杂度：O(nlog2n)
空间复杂度：O(1)

归并排序

/**
 * 归并排序
 */
void MergeSort(Item *data, int len) {
    MergeSortImpl(data, 1, len);
}

void MergeSortImpl(Item *data, int low, int high) {
    if (low < high) {
        int mid = (low + high) / 2;
        MergeSortImpl(data, low, mid);
        MergeSortImpl(data, mid + 1, high);
        Merge(data, low, mid, high);
    }
}

/**
 * 合并 i:mid     mid+1:high
 */
void Merge(Item *data, int low, int mid, int high) {
    Item *buffer = (Item *) malloc((high + 1) * sizeof(Item));
//    memset(buffer, 0, (high + 1) * sizeof(Item));
    for (int i = low; i <= high; ++i) {
        buffer[i] = data[i];
    }

    int i = low, j = mid + 1;
    int k = i;
    for (; i <= mid && j <= high; k++) {
        if (buffer[i].value <= buffer[j].value)
            data[k] = buffer[i++];
        else
            data[k] = buffer[j++];
    }

    while (i <= mid)
        data[k++] = buffer[i++];
    while (j <= high)
        data[k++] = buffer[j++];

    free(buffer);
    buffer=NULL;
}

稳定
k时间复杂度：O(nlog2n)
空间复杂度：O(n)

基数排序

数字有d位 ,每位采用r进制

一趟排序需要分配r个队列
进行d趟分配和收集,一趟分配需要O(n),一趟收集需要O®

稳定
时间复杂度：O(d(n+r))
空间复杂度：O( r )

外部排序

处理大批量数据

首先,根据内存缓冲区大小,将外存上含n个记录的文件分成若干长度为h的子文件,依次读入内存,并利用内部排序算法进行排序,使得初始归并段有序,并将有序的初始归并段写回外存

然后,对初始归并段进行逐趟归并,使归并段逐渐由小到大,直至得到整个有序文件为止。

外部排序时间：内部排序时间+外村读写时间+内部归并时间


文件记录：n     归并段长：h

归并段数：r= &lceil;n/h&rceil;


采用m路归并算法：

归并趟数： ⌈logmr⌉
整体文件I/O：⌈logmr⌉ +1

减少IO时间：

  1. 增加归并路数
  2. 减少归并段数

失败树

目的：增加归并路数

前因

S趟归并需要比较的次数：

S(n-1)(m-1)=⌈logmr⌉ (n-1)(m-1)

因此不能盲目增加归并路数m！！！

失败树

增加m并且使比较时间不会因此增加

失败树

比较次数：
⌈logmr⌉ (n-1) ⌈log2m⌉ = (n-1) ⌈log2r⌉

与m无关,故此时增加归并路数,对比较次数无影响

过程

but: 怎加m 会对内存缓冲区的个数有要求。

置换选择排序

减小r的数目 获取长度不等的归并段

待排序文件：17,23,46,53,11,9,78,8,56,36,21,96

输出文件FO工作区WA输入文件FI
17,23,4653,11,9,78,8,56,36,21,96
1723,46,5311,9,78,8,56,36,21,96
17,2346,53,119,78,8,56,36,21,96
17,23,4653,11,978,8,56,36,21,96
17,23,46,5311,9,788,56,36,21,96
17,23,46,53,7811,9,856,36,21,96
17,23,46,53,78 #11,9,856,36,21,96
811,9,5636,21,96
8,911,56,3621,96
8,9,1156,36,2196
8,9,11,2156,36,96
………
8,9,11,21,36,56,96#

两个初始归并段：

17,23,46,53,78
8,9,11,21,36,56,96

最佳归并树

结合哈夫曼树 （m阶哈夫曼树：树中节点的度数为m或0）

a. 通过置换选择排序获取了初始归并段
b. 构造成m阶哈夫曼树

n0+nm -1=度数=nm * m

(m-1)nm =n0-1

nm=(n0-1)/(m-1)

nm整数

补充段数目：(n0’-1)%(m-1)
n0=初始归并段数目+ 补充段数目

例. 三叉树T中有6个叶节点的权分别为2，3，4，5，6，7，T的带权外部路径长度最小为： 46 （构造3阶哈夫曼树）

补充：5%2=1 补充1个段

13+18+15=46

最小：
根
6，7
4，5
0，2，3

guanyue.space
关注
专栏目录
广州大学 数据结构实验报告 实验四 查找和排序算法实现
05-23
实验报告的主题聚焦于数据结构中的查找和排序算法实现，这是计算机科学中基础且重要的部分，尤其是在处理大量数据时。以下是对这些算法的详细说明： 1. **插入排序**：插入排序的基本思想是将一个记录插入到已经排...
Verilog/C++实现排序算法：Verilog/C++实现排序算法：冒泡排序、选择排序、并行全比较排序、串行全比较排序
06-27
本文将探讨如何使用这两种语言实现几种基本的排序算法：冒泡排序、选择排序，以及两种全比较排序（并行和串行）。 首先，让我们了解一下排序算法。排序是计算机科学中最基础的操作之一，它涉及到将一组数据按照特定...
基本的排序算法原理与实现
松子茶的专栏
08-25 3041
本节主要介绍基本的排序算法 ，即：插入排序，选择排序，冒泡排序.插入排序首先考虑data中的前两个元素，即data[0]和data[1]。如果它们的次序颠倒了，就交换它们。然后，考虑第三个元素data[2],将其插入到合适的位置上。如果data[2]同时小于data[0]和data[1],那么data[0]和data[1]都要移动一个位置；data[0]放在位置1上，data[1]放在位置2上，而将data[2]放在位置0上。如果data[2]小于data[1]，而不于data[0],那么只须把data[1
几种基本排序算法的实现
林竹清_清清清
04-16 223
package test.sort; import org.junit.Test; /** @Author lingl @Date 2020/4/16 */ public class SortTest { @Test public void test() { int[] array = new int[] {5, 3, 4, 1, 3, 6, 2}; quickSo...
基本排序算法的思想及代码实现
qq_37429343的博客
07-30 211
有一个有序表为1,5,8,11,19,22,31,35,40,45,48,49,50当二分查找值为48的结点时，查找成功需要比较的次数。System.out.println("=================不稳定================");System.out.println("=================稳定=================");②A[M]>T，中间值右侧的其它元素都大于T，无需比较，中间索引左边去找，M-1设置为右边界，重新查找。......
排序1+2：交换排序(ExchangeSort)，选择排序(SelectSort)和插入排序(Insertsort)
01-27 239
交换排序，插入排序和选择排序都是很简单也很基础的排序算法。在世面上各种各样的算法和数据结构的书中都很轻易地找的到他们的踪影。在这儿写出来不外乎是加深自己的印象，也为有需要的朋友做一个参考。 1 交换排序 交换排序是一种很简单的排序方法。其主要思想如下： （1）利用要排序范围中的第0个数据d[i]与范围中其它数据d[j]相比较。如果前面的数据比后面大，那么就交换这两个数据（就...
交换排序算法实现
aiba1227的博客
09-18 98
#include <iostream> template <class elem> void swap(elem a[], int p1, int p2) { elem tmp = a[p1]; a[p1] = a[p2]; a[p2] = tmp; } template <class elem> ...
用C++实现基本排序算法
最新发布
06-29
只看我文中指出的排序算法的MySort相关文件即可，其他都是多余文件不用管，打开VS（最好2022以上的版本，版本太低可能会有不兼容的报错）
C语言基本排序算法之插入排序与直接选择排序实现方法
08-29
C语言基本排序算法之插入排序与直接选择排序实现方法 C语言基本排序算法之插入排序与直接选择排序实现方法是计算机科学中最基本的排序算法之一。排序算法是指将一组无序的数据按照一定的规则排列成有序的序列的过程...
C++实现希尔、快速、堆排序、归并排序算法
01-21
本文将详细介绍C++中实现的希尔排序、快速排序、堆排序和归并排序这四种经典排序算法。 希尔排序，由Donald Shell于1959年提出，是一种改进的插入排序。它的基本思想是通过设置一个增量序列，将待排序的元素按照...
编程实现希尔、快速、堆排序、归并排序算法。要求首先随机产生10000个数据存入磁盘文件，然后读入数据文件，分别采用不同的排序方法进行排序并将结果存入文件中。
热门推荐
dawn2dusk的博客
03-27 1万+
编程实现希尔、快速、堆排序、归并排序算法。要求首先随机产生10000个数据存入磁盘文件，然后读入数据文件，分别采用不同的排序方法进行排序并将结果存入文件中。一、算法思想描述（用一个长度为10的序列进行模拟）1.希尔排序希尔排序是对直接插入排序的改进，它利用了直接插入排序在序列个数少且基本有序的情况下排序效率较高的性质。首先获取整数d，将序列分出d个长度为d的子序列，选取中间（或中间靠后）的位置作为...
排序算法（c语言实现）
D来之
08-26 712
作为一个程序猿，编写程序，排序算法算是最基本的了。这篇博客中，我尽量以最通俗易懂的语言，最简单的代码来讲清楚这些比较常见的排序算法。 好了，首先来看一下各种排序算法的效率和稳定性方面的总结（这张图很好，网上找的）： 下面我就根据这张图来说明各种排序算法。 一.插入排序 1.直接插入排序 2.shell排序 扩展几个： 1.折半插入排序 2. 二.选择排序 1.直接选择排
面试常考：排序算法2（希尔排序，归并排序，堆排序）
wake_alone
08-16 711
希尔排序 O(N^d),最坏O(N^2),不稳定 void ShellSort(int A[],int N) { /*O(N^d),最坏O(N^2),不稳定*/ int Si,D,P,i; int tmp; int Sedgewick[]={929,505,209,109,41,19,5,1,0};//互质的复杂度最小 for (Si=0;Sedgewick[Si]&gt;=N;...
堆的相关操作以及堆排序
Yinghuhu333333的博客
07-06 359
堆:它的物理结构可以看做是数组,而逻辑结构可以看做一颗完全二叉树. 堆有大堆和小堆之分: 大堆:根节点是当前所有元素中的最大值,而对于每一个子树,其子树也是一个大堆. 小堆:根节点是当前所有元素中的最小值,而对于每一个子树,其子树也是一个小堆. 堆的应用: 堆还可用来表示优先级队列.队列:即只允许队列的队首进行删除,而队尾进行插入.而优先级队列就是一组有序的队列.在堆中,进行插入和...
数据结构与算法(二十)堆排序
SunSatan的博客
05-20 399
堆排序(Heap Sort)就是对简单选择排序进行的一种改进，这种改进的效果是非常明显的。 1、堆 我们首先要知道什么是堆？ 堆是具有下列性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆，或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。 这里需要注意从堆的定义可知，根结点一定是堆中所有结点的最大(小)者。 二叉树拥有这样一个性质 ：如果对一棵有n个...
【算法】排序算法-直接插入排序
hwwjason的博客
11-13 266
直接插入排序是一种最简单的排序方法，原理就是把一个记录插入到已经排序好的表中，然后得到一个新的有序表。
Java选择和冒泡排序
自深深处
09-20 452
import java.util.Scanner; public class 选择排序 { /* * 思想： * N个数比较N趟 * 每趟拿出一个数字 定义一个最大的MAX 与其他数字做比较填入最大 * 以此进行 * */ public static void main(String args[]){ Scanner
常见排序算法基本原理及实现（快排，归并，堆排，直接插入.....）
weixin_47792933的博客
12-05 4157
文章目录常见排序算法总览1.概念1.1 排序1.2 稳定性（重要）2.插入排序2.1直接插入排序-原理2.2代码实现2.3性能分析3.希尔排序3.1 原理3.堆排序3.1原理 常见排序算法总览 1.概念 1.1 排序 排序就是使待排序序列，按照其中的某个或某些关键字的大小（以什么作为比较基准），递增或递减的排列起来的操作。平时如果提到排序，通常指的是排升序（非降序）。通常意义上的排序，都是指的原地排序(in place sort)。 1.2 稳定性（重要） 两个相等的数据，如果经过排序后，排序算法能保证其
C语言实现基本排序算法详解
算法学习入门之使用C语言实现各大基本的排序算法 以下是从给定的文件中生成的相关知识点： 1. 排序算法的稳定性： 稳定排序是指在排序过程中，相等的元素保持它们在排序之前的相对次序。例如，一组数排序前是a1,a2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值