冒排、简单排、插入排、折半插入排、快排、堆排、希尔、归并

最新推荐文章于 2022-10-03 22:56:46 发布
最新推荐文章于 2022-10-03 22:56:46 发布
阅读量282 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43237242/article/details/90678760
版权

冒泡排序：（稳定）

void maopao(int *a, int n)
{
    for(int i=1; i<=n-1; ++i)
        for(int j=1; j<=n-i; ++j)
            if(a[j] > a[j+1])
            {
                int tem = a[j];
                a[j] = a[j+1];
                a[j+1] = tem;
            }
}

简单选择排序：（不稳定）

void simple(int *a, int n)
{
    for(int i=1; i<=n; ++i)
    {
        int k = i;
        for(int j=i+1; j<=n; ++j)
        {
            if(a[k] > a[j])
                k = j;
        }
        if(i!=k)
        {
            int tem = a[k];
            a[k] = a[i];
            a[i] = tem;
        }
    }
}

希尔排序：（不稳定）

void shell(int *a, int n)
{
    int dk = n;
    while(dk > 1)
    {
        dk = dk/3+1;
        for(int i=dk; i<=n; ++i)
        {
            int key = a[i];
            for(int j = i-dk; j>0; j-=dk)
            {
                if(key < a[j])
                {
                    int tem = a[j];
                    a[j] = key;
                    a[j+dk] = tem;
                }
            }
        }
    }
}

插入排序：（稳定）

void Insert(int *a, int n)
{
    for(int i=2; i<=n; ++i)
    {
        if(a[i] < a[i-1])
        {
            int x=a[i], j;
            a[i] = a[i-1]; //后移。。。
            for(j=i-2; j!=0 && x<a[j]; --j)
                a[j+1] = a[j];
            a[j+1] = x;
        }
    }
}

折半插入排序：（稳定）

void zheinsert(int *a, int n)
{
    for(int i=2; i<=n; ++i)
    {
        int x = a[i];
        int low=1, high = i-1;
        while(low<=high)
        {
            int m = (low+high)/2;
            if(x < a[m])
                high = m-1;
            else
                low = low+1;
        }
        for(int j=i-1; j>=high+1; --j)
            a[j+1] = a[j];
        a[high+1] = x;
    }
}

快速排序：（不稳定）

int par(int *a, int low, int high)
{
    int y = a[low];              //
    while(low < high)
    {
        while(low < high && a[high] >= y) --high;
        if(low<high) {a[low] = a[high]; ++low;};
        while(low < high && a[low] <= y) ++low;
        if(low < high){a[high] = a[low]; --high;};
    }
    a[low] = y;
    return low;
}

void Sort(int *a, int low, int high)
{
    if(low < high)
    {
        int x = par(a, low, high);
        Sort(a, low, x-1);
        Sort(a, x+1, high);
    }
}

堆排序：（不稳定）

void heap(int *a, int s, int m)
{
    int rc = a[s];
    for(int j=2*s; j<=m; j*=2)              //沿数较大的孩子结点向下筛选
    {
        if(j < m && a[j] < a[j+1]) ++j;  //选择较大的儿子结点
        if(rc >= a[j]) break;           //rc插入到位置s上
        a[s] = a[j];
        s = j;
    }
    a[s] = rc;
}

void heapsort(int *a, int n)
{
    for(int i=n/2; i>0; --i)    //创建大堆
        heap(a, i, n);
    for(int i=n; i>1; --i)
    {
        int x = a[1];
        a[1] = a[i];
        a[i] = x;
        heap(a, 1, i-1);
    }
}

归并排序：（稳定）

void Count(int *a, int *temp, int l, int r)//归并
{
    if(r == l)
        return ;//结束条件
    int m = (l + r) >> 1;
    Count(a, temp, l, m);				//temp为暂存空间
    Count(a, temp, m + 1, r);//二分查找
    int i = l, j = m + 1, k = l;
    while(j <= r || i <= m)
    {
        if(j > r || (i <= m && a[i] < a[j]))
            temp[k++] = a[i++];
        else
            temp[k++] = a[j++];//ans+=m-i+1;//ans为整个序列的逆序数
    }
    for(i = l; i <= r; i++)
        a[i] = temp[i];
}

测试样例：
8
49 38 65 97 76 13 27 49
样例输出：
在这里插入图片描述完全代码：

//#include<bits/stdc++.h>
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<string.h>
#include<math.h>
using namespace std ;
typedef long long ll;
#define MAXN 105
#define INF 0x3f3f3f3f
#define MALL (Bithrnode *)malloc(sizeof(Bithrnode));

void maopao(int *a, int n)
{
    for(int i=1; i<=n-1; ++i)
        for(int j=1; j<=n-i; ++j)
            if(a[j] > a[j+1])
            {
                int tem = a[j];
                a[j] = a[j+1];
                a[j+1] = tem;
            }
}

void simple(int *a, int n)
{
    for(int i=1; i<=n; ++i)
    {
        int k = i;
        for(int j=i+1; j<=n; ++j)
        {
            if(a[k] > a[j])
                k = j;
        }
        if(i!=k)
        {
            int tem = a[k];
            a[k] = a[i];
            a[i] = tem;
        }
    }
}

void shell(int *a, int n)
{
    int dk = n;
    while(dk > 1)
    {
        dk = dk/3+1;
        for(int i=dk; i<=n; ++i)
        {
            int key = a[i];
            for(int j = i-dk; j>0; j-=dk)
            {
                if(key < a[j])
                {
                    int tem = a[j];
                    a[j] = key;
                    a[j+dk] = tem;
                }
            }
        }
    }
}

void Insert(int *a, int n)
{
    for(int i=2; i<=n; ++i)
    {
        if(a[i] < a[i-1])
        {
            int x=a[i], j;
            a[i] = a[i-1]; //后移。。。
            for(j=i-2; j!=0 && x<a[j]; --j)
                a[j+1] = a[j];
            a[j+1] = x;
        }
    }
}

void zheinsert(int *a, int n)
{
    for(int i=2; i<=n; ++i)
    {
        int x = a[i];
        int low=1, high = i-1;
        while(low<=high)
        {
            int m = (low+high)/2;
            if(x < a[m])
                high = m-1;
            else
                low = low+1;
        }
        for(int j=i-1; j>=high+1; --j)
            a[j+1] = a[j];
        a[high+1] = x;
    }
}

int par(int *a, int low, int high)
{
    int y = a[low];              //
    while(low < high)
    {
        while(low < high && a[high] >= y) --high;
        if(low<high) {a[low] = a[high]; ++low;};
        while(low < high && a[low] <= y) ++low;
        if(low < high){a[high] = a[low]; --high;};
    }
    a[low] = y;
    return low;
}

void Sort(int *a, int low, int high)
{
    if(low < high)
    {
        int x = par(a, low, high);
        Sort(a, low, x-1);
        Sort(a, x+1, high);
    }
}

void heap(int *a, int s, int m)
{
    int rc = a[s];
    for(int j=2*s; j<=m; j*=2)              //沿数较大的孩子结点向下筛选
    {
        if(j < m && a[j] < a[j+1]) ++j;  //选择较大的儿子结点
        if(rc >= a[j]) break;           //rc插入到位置s上
        a[s] = a[j];
        s = j;
    }
    a[s] = rc;
}

void heapsort(int *a, int n)
{
    for(int i=n/2; i>0; --i)    //创建大堆
        heap(a, i, n);
    for(int i=n; i>1; --i)
    {
        int x = a[1];
        a[1] = a[i];
        a[i] = x;
        heap(a, 1, i-1);
    }
}

void Count(int *a, int *temp, int l, int r)//归并
{
    if(r == l)
        return ;//结束条件
    int m = (l + r) >> 1;
    Count(a, temp, l, m);				//temp为暂存空间
    Count(a, temp, m + 1, r);//二分查找
    int i = l, j = m + 1, k = l;
    while(j <= r || i <= m)
    {
        if(j > r || (i <= m && a[i] < a[j]))
            temp[k++] = a[i++];
        else
            temp[k++] = a[j++];//ans+=m-i+1;//ans为整个序列的逆序数
    }
    for(i = l; i <= r; i++)
        a[i] = temp[i];
}

void print(int *a, int n)
{
    for(int i=1; i<=n; ++i)
        cout << a[i] << ' ';
    cout << '\n' << '\n';
}

int main()
{
    int A[MAXN];
    int B[MAXN];
    int C[MAXN];
    int D[MAXN];
    int E[MAXN];
    int F[MAXN];
    int G[MAXN];
    int H[MAXN];
    int ret[MAXN];
    int n;
    cin >> n;
    for(int i=1; i<=n; ++i)
    {
        cin >> A[i];
        H[i] = G[i] = F[i] = E[i] = D[i] = C[i] = B[i] = A[i];
    }
    cout << '\n';
    cout << "--------冒泡排序--------" << '\n';
    maopao(A, n);
    print(A, n);
    cout << "-------简单选择排序-------" << '\n';
    simple(B, n);
    print(B, n);
    cout << "--------希尔排序---------" << '\n';
    shell(C, n);
    print(C, n);
    cout << "--------插入排序-------" << '\n';
    Insert(D, n);
    print(D, n);
    cout << "--------折半插入排序------" << '\n';
    zheinsert(E, n);
    print(E, n);
    cout << "---------快速排序---------" << '\n';
    Sort(F, 1, n);
    print(F, n);
    cout << "----------堆排序----------" << '\n';
    heapsort(G, n);
    print(G, n);
    cout << "---------归并排序---------" << '\n';
    Count(H, ret, 1, n);
    print(H, n);
    return 0;
}
浦柳人
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
js排序算法，冒泡，选择，插入，快速排序
06-03 217
排序算法：冒泡，选择，插入，快速排序 // 冒泡排序 function bubbleSort(arr){ var start = Date.now(); for(var i=0,len=arr.length;i<len;i++){ var temp; for(var j=i+1;j<len-1;j++){ if...
快排，插入两种排序方法
weixin_49203549的博客
07-19 126
快排: void quickSort(int arr[],size_t left,size_t right){ if(left >= right){ return; } int key = arr[left];//标准key 放在合适的位置 使得左边的元素全部<=key 右边全部的元素>=key int i=left,j=right; while(i<j){ //右边找一个比key小的 while(i<j && arr[j]>=key){ –j;
快排改进（快排+插入）
kai_ITthinker的专栏
03-21 634
/* 快排改进算法 快排+插入，当集合较小时，不再排序，由于已经通过快排，保证基本有序，移动次数不会太多，此时改用插入排序， */ static void quickSortSection(std::vector& vec, int start, int end, int k) { if ((end - start) > k) { if (start >= end)
排序（冒泡，选择，插入，快排，堆排）
无声的等候
07-01 388
#include using namespace std; //冒泡排序 void BubbleSort(int arr[], int n) {  for (int i = 0; i  {   //比较两个相邻元素   for (int j = 0; j   {    if (arr[j]>arr[j + 1])    {     int t = arr[j];
折半插入排序稳定吗_【算法】希尔排序 （ 插入排序3.0版本已经发布，是否更新？ (￣▽￣") ）...
weixin_42505252的博客
01-29 100
【参考资料】《算法（第4版）》 — — Robert Sedgewick， Kevin Wayne在本篇笔记里，我从简单的插入排序，到希尔排序，中间的一系列算法，看起来就像是插入排序的“发展史”一般。这些点分别是：直接插入排序（插入排序1.0版本）基于插入排序的简单优化（插入排序1.1和1.2版本）折半插入排序（插入排序2.0版本）希尔排序（插入排序3.0版本）直接插入排序（插入排...
快排和插入排序
xuyuanshu123的博客
10-20 228
public class CombineQuickSortInsertionSort { private long[] data; private int len; public CombineQuickSortInsertionSort(int max) { data = new long[max]; len = 0; } publ...
算法 | 二分法与折半插入排序【这是开端吗？】
做技术人 · 产优质博客 · 找好工作
10-03 875
细究二分法与折半插入排序的联系，50张算法图解，手把手带你调试理清算法脉络
二分实现插排
niejunhongbupt的专栏
11-04 734
[/color][color=darkred][size=medium][/size]转载 最近在研究Java数据结构和算法 练习写了一个用插入排序的算法 查找部分使用二分查找实现的 和大家分享一下 呵呵 还请各位大牛多指教啊 呵呵 Java代码  import java.util.Random;    public class InsertSort {     
快排、冒泡法
weixin_44629187的博客
07-03 125
/******************************************************* *快速排序 (比较排序类) *每次排序将待排记录分割两部分,一部分都比关键字小,一部分都比关键字大 ********/ public void quickSort(int[] L) { Qsort(L,1,L.length-1); } publ...
堆排序两种写法
qq_40795475的博客
04-27 325
#include <stdio.h> // #include <stdlib.h> #define maxn 1000 int a[maxn]; void buildheap(int low,int high) { while(1)//除非满足大顶堆性质 否则不断的检查 { int i=2*low;//左 in...
必会算法：冒泡排序、快排、归并排序、折半查找、大根堆（Java版）
AI_盲的博客
03-03 695
//二分查找 static int binaryFind(int[] n, int key, int left, int right) { if (left > right) { return -1; } int low = left; int high = right; int mid = 0; while (low <= high) { mid = (lo
快排，堆排序，折半查找算法（Java版）
我的E家
11-09 1160
1. 快速排序 package com.zhou.algorithm; //快速排序 public class AlgorithmQuickSort { public int partition(Integer[] list, int low, int high) { int par = list[low]; //数组的第一个作为中轴 whi
大小根堆的普通写法(包含堆排序)
01-10 136
堆排序 转载于:https://www.cnblogs.com/fanguangdexiaoyuer/p/8254267.html
比冒泡效率更高的快排方法。
weixin_41202652的博客
12-25 632
方法1： def kp(ls):     if len(ls)         return ls     mins = []     maxs = []     for i in ls[1:]:         if i             mins.append(i)         elif i >= ls[0]:             maxs.append(
快排改进版——插入 三分 九分 双指针综合版
versencoder的博客
10-07 989
快排改进版
排序的总结(快速排序、插入排序)
weixin_39940543的博客
12-11 4760
一、简单插入排序： 插入排序是简单排序中最快的排序算法，虽然时间复杂度仍然为O(n*n)，但是却比冒泡排序和选择排序快很多。 （1）原理： 假设前面的数列均为有序，逐一比较，如果比要插入的数大（从小到大排序）或小（从大到小排序），就互换位置。从将数列的第二个数设为要插入的数开始遍历数列。 （2）例子： （3）代码： public int[] kthLargestElement( int[]...
冒泡排序
热门推荐
zhm的博客
02-15 5万+
冒泡排序 1.冒泡排序思想 让数组当中相邻的两个数进行比较，数组当中比较小的数值向下沉，数值比较大的向上浮！外层for循环控制循环次数，内层for循环控制相邻的两个元素进行比较。 2. 编码 package com.zhmcode.bubblesort; /** * Created by zhmcode on 2019/2/15 0015. */ public class MyBubbleS...
实验九 排序(插入和快排）
tian246319的博客
01-08 759
实验九 排序 【完成时间】2020年1月6日 【实验要求】 （1）至少要有一种排序算法的性能优于O(n2) （2）对实现的排序算法进行实验比较，实验比较数据参见教材7.8章节 （3）排序算法要基于教材，测试输入的整数数据文件（5个，文件中数据规模分别是100，1K，10K，100K和1M），排序结果也要输出到文件中。 （4）要在屏幕上输出排序过程所花费时间。 （5）提交最终实验作业。用附件的形式，提交两个文件：一个压缩包（包含源码和5个用于排序测试的数据文件）;一个pdf文档（文档中包含实验日志和一个根据基
在排好序的基础上折半查找
最新发布
06-10
在排好序的数组中进行折半查找，可以通过以下步骤实现： 1. 确定查找区间的左右边界left和right，初始时left为0，right为数组长度减1。 2. 计算中间位置mid，即mid = (left + right) / 2。 3. 判断所要查找的元素与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值