直接查找排序，归并排序，快速排序，计数排序 ，堆排 C++实现

最新推荐文章于 2024-04-28 10:27:05 发布
最新推荐文章于 2024-04-28 10:27:05 发布
阅读量604 收藏
点赞数
分类专栏： 算法 文章标签： c++ struct merge system null vector
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jjiang06/article/details/6680599
版权

/*insert sort*/

/*时间复杂度 O(n2)*/

#include<iostream>

using namespace std;
void insertion(int* a);

void main()
{
    int arraya[10]={2,4,6,8,7,9,12,1,11,0};
    insertion(arraya);
    cout<<"the arraya after insertion:";
    for(int i=0;i<10;i++)
        cout<<" "<<arraya[i];
    system("pause");
}
void insertion(int* a )
{
    int i,j;
    int length=10;
    for(i=1;i<length;i++)
    {
        int key=a[i];
        j=i-1;
        while(j>=0&&a[j]>key)
            {
                a[j+1]=a[j];
                j--;
            }
        a[j+1]=key;
    }

}

/* merge sort*/

/*时间复杂度 O(nlogn) */

/*数组实现*/

#include<iostream>
using namespace std;

void merge(int a[], int p, int q, int r)
{
    int i,j,k,n1,n2;
    n1=q-p+2;//n1和n2要多留一位给INT_MAX; 所以一个要加2，一个要加1；

    n2=r-q+1;

    int l[11];
    int m[11];
    int pp=p;//P是中间那个数，不能动。所以我们重新复制给PP；
    for(i=0;i<n1-1;i++)
    {
        l[i]=a[pp];
        pp++;//别忘了pp也要自加，我之前就忘了这点，同理qq也是
    }
    l[n1-1]=INT_MAX;//因为我是用数组做的，而不是vector，所以没法动态分配。只能用类库里的INT_MAX来限制每次大小不一样的数组长度
    int qq=q+1;
    for(j=0;j<n2-1;j++)
    {
        m[j]=a[qq];
        qq++;
    }
    m[n2-1]=INT_MAX;
    i=j=0;
    for(k=p;k<=r;k++)
    {
        if(l[i]<=m[j])//如果数组l的值小就把l数组的值放进原先数组里
        {
            a[k]=l[i];
            i++;
        }
        else
        {
            a[k]=m[j];
            j++;
        }
    }
}

void mergesort(int a[], int p, int r)
{
    if(p<r)
    {
        int q;
        q=(p+r)/2;
        mergesort(a,p,q);
        mergesort(a,q+1,r);
        merge(a, p,q, r);
    }

}
void main()
{
    int arraya[10]={1,3,2,5,6,4,7,12,9,10};
    mergesort(arraya,0,9);
    for(int i=0;i<10;i++)
        cout<<arraya[i]<<" ";
    cout<<endl;
    system("pause");
}

/*用vector实现，这样的动态数组就可以不用考虑最大值了，方便很多*/

#include<iostream>
using namespace std;
#include<vector>

void merge(vector<int>&A,vector<int>&temp,int p, int q, int r);
void mergesort(vector<int>&A, vector<int>&temp,int p, int r);
void mergeSort(vector<int>&A);

void main()
{
    vector<int> ve;
        ve.push_back(3);
        ve.push_back(5);
        ve.push_back(1);
        ve.push_back(2);
        ve.push_back(6);
        ve.push_back(4);
        ve.push_back(0);
        ve.push_back(9);
        ve.push_back(8);
        ve.push_back(7);    
    mergeSort(ve);
    for(int i=0;i<ve.size();i++)
        cout<<ve[i];
    cout<<endl;

}

void merge(vector<int>&A,vector<int>&temp,int p, int q, int r)
{
    int i=p;
    int j=q+1;
    int t=p;
    while(i<=q&&j<=r)
    {
        if(A[i]<A[j])
            temp[t++]=A[i++];
        else
            temp[t++]=A[j++];
    }
    while(i<=q)
        temp[t++]=A[i++];
    while(j<=r)
        temp[t++]=A[j++];
    for(int k = p; k<= r; ++k)
        A[k] = temp[k];
}
void mergesort(vector<int>&A, vector<int>&temp,int p, int r)
{
    if(p<r)
    {    
        int    q;
        q=(p+r)/2;
        mergesort(A,temp,p,q);
        mergesort(A,temp,q+1,r);
        merge(A,temp,p,q,r);
    }
}
void mergeSort(vector<int>&A)
{
    vector<int>temp(A.size());
    mergesort(A,temp,0,A.size()-1);
}


/*mergesort*/

/*链表实现*/

#include<iostream>
using namespace std;

struct node
{
    node(int v =0, node *n =0 )
        :value(v),next(n)
    {}
    int value;
    node* next;
};

void frontbacksplit(struct node* source, struct node **frontRef, struct node **backRef)
{    
    struct node *slow;
    struct node *fast;

    slow=source;
    fast=source->next;
    while(fast!=NULL)
    {
        fast=fast->next;
        if(fast!=NULL)
        {
            slow=slow->next;
            fast=fast->next;
        }
    }
    *frontRef=source;
    *backRef=slow->next;
    slow->next=NULL;

}

struct node* sortedmerge(struct node *a, struct node *b)
{
    struct node *result=NULL;
    struct node** lastptrref=&result;

    while(a!=0&&b!=0)
    {
        if(a->value<=b->value)
        {
            *lastptrref=a;
            a=a->next;
            lastptrref=&((*lastptrref)->next);
        }
        else
        {    
            *lastptrref=b;
            b=b->next;
            lastptrref=&((*lastptrref)->next);

        }
    }
    if(a!=0)
        *lastptrref=a;
    if(b!=0)
        *lastptrref=b;

    return(result);
}
void mergesort(struct node** headRef)
{
    if((*headRef)==0||(*headRef)->next==0)
        return;
    struct node* head=*headRef;
    struct node* a=NULL;
    struct node* b=NULL;

    frontbacksplit(head,&a,&b);
    mergesort(&a);
    mergesort(&b);

    *headRef=sortedmerge(a,b);
}

void main()
{
    node *node9=new node(1);
    node *node8=new node(2,node9);
    node *node7=new node(3,node8);
    node *node6=new node(4,node7);
    node *node5=new node(5,node6);
    node *node4=new node(6,node5);
    node *node3=new node(7,node4);
    node *node2=new node(8,node3);
    node *node1=new node(9,node2);

    node *head=node1;
    node *runner;
    runner=head;

    while(runner)
    {
        std::cout<<runner->value<<" ";
        runner=runner->next;
    }
    std::cout<<"\n";

    mergesort(&head);

    runner=head;
    while(runner)
    {
        std::cout<<runner->value<<" ";
        runner=runner->next;
    }
    std::cout<<"\n";

    system("pause");
}


/* quicksort-非随机*/

/*时间复杂度 O(nlogn) */

#include<iostream>
using namespace std;

int partition(int A[8],int size,int p, int r)
{
    int i,j,x,temp;
    x=A[r];
    i=p-1;
    for(j=p;j<=r-1;j++)
    {
    if(A[j]<=x)
        {
            i=i+1;
            temp=A[i];
            A[i]=A[j];
            A[j]=temp;
        }
    cout<<endl;
    for(int z=0;z<8;z++)
        cout<<A[z]<<" ";
    cout<<endl;
    }
    temp=A[i+1];
    A[i+1]=A[r];
    A[r]=temp;
    return i+1;
}
void quicksort(int A[8],int size, int p, int r)
{
    if(p<r)
    {int q=partition(A,size,p,r);
    quicksort(A,size,p,q-1);
    quicksort(A,size,q+1,r);}
}

int main()
{
    int A[8]={2,8,7,1,3,5,6,4};
    int z;
    cout<<"before quicksort: ";
    for(z=0;z<8;z++)
    {
    cout<<A[z]<<" ";
    }
    cout<<endl;
    quicksort(A,8,0,7);
    cout<<"after quicksort: ";
    for(z=0;z<8;z++)
    {
    cout<<A[z]<<" ";
    }
    cout<<endl;
    system("pause");
    return 0;
}

/*快排-随机*/

#include<iostream>
using namespace std;
#include<ctime>
#include<cstdlib>

int random(int p, int r)
{
    int size=r-p+1;
    return p+rand()%size;
}

int partition(int A[8],int size,int p, int r)
{
    int i,j,x,temp,s;
    s=random(p,r);
    temp=A[r];
    A[r]=A[s];
    A[s]=temp;

    x=A[r];
    i=p-1;
    for(j=p;j<=r-1;j++)
    {
    if(A[j]<=x)
        {
            i=i+1;
            temp=A[i];
            A[i]=A[j];
            A[j]=temp;
        }
    cout<<endl;
    for(int z=0;z<8;z++)
        cout<<A[z]<<" ";
    cout<<endl;
    }
    temp=A[i+1];
    A[i+1]=A[r];
    A[r]=temp;
    return i+1;
}
void quicksort(int A[8],int size, int p, int r)
{
    if(p<r)
    {int q=partition(A,size,p,r);
    quicksort(A,size,p,q-1);
    quicksort(A,size,q+1,r);}
}

int main()
{
    int A[8]={2,8,7,1,3,5,6,4};
    int z;
    cout<<"before quicksort: ";
    for(z=0;z<8;z++)
    {
    cout<<A[z]<<" ";
    }
    cout<<endl;
    quicksort(A,8,0,7);
    cout<<"after quicksort: ";
    for(z=0;z<8;z++)
    {
    cout<<A[z]<<" ";
    }
    cout<<endl;
    system("pause");
    return 0;
}

/*counting sort*/

#include<iostream>
using namespace std;

void countsort(int A[ ], int sizea, int B[], int sizeb,int k)
{
    int i;
    int C[10];
    for(i=0;i<k;i++)
    {
        C[i]=0;
    }
    for(i=0;i<sizea;i++)
    {
        C[A[i]]=C[A[i]]+1;
    }
    for(i=1;i<k;i++)
    {
        C[i]=C[i]+C[i-1];
    }
    for(i=sizea-1;i>=0;i--)
    {
        B[C[A[i]]-1]=A[i];
        C[A[i]]=C[A[i]]-1;
    }
}

void main()
{
    int i;
    int A[]={2,5,3,0,2,3,0,3};
    int B[]={0,0,0,0,0,0,0,0};
    countsort(A,8,B,8,6);
    for(i=0;i<8;i++)
    {
        cout<<B[i]<<" ";
    }
}

/*heapsort*/

/*时间复杂度(nlogn)*/

#include<iostream>
using namespace std;

void maxheapify(int A[],int i,int size)
{
    int l=2*i+1;
    int r=2*i+2;
    int large=i;
    int temp;

    if(l<=size-1&&A[l]>A[i])
        large=l;
    if(r<=size-1 && A[r]>A[large])
        large=r;
    if(large!=i)
    {
        temp=A[large];
        A[large]=A[i];
        A[i]=temp;
        maxheapify(A,large,size);
    }
}
void buildmaxheap(int A[],int size)
{
    
    int i;
    for(i=size/2;i>=0;i--)
    {
        maxheapify(A,i,size);
    }
}
void heapsort(int A[],int size)
{
    int i;
    buildmaxheap(A,size);
    for(i=0;i<size;i++)
        cout<<A[i]<<" ";
    cout<<endl;
    for(i=size-1;i>0;i--)
    {
        int temp;
        temp=A[0];
        A[0]=A[i];
        A[i]=temp;
        size--;
        maxheapify(A,0,size);
    }
}
void main()
{
    int i;
    int AA[10]={2,4,23,1,3,5,6,9,7,10};
    heapsort(AA,10);
    for(i=0;i<10;i++)
    {cout<<AA[i]<<" ";}
}



jjiang06
关注
专栏目录
十大经典排序算法(C++、Java实现)动图演示及代码解析-冒泡排序、选择排序、插入排序、快速排序、堆排序、希尔排序、归并排序、计数排序、桶排序、基数排序
SmallBottle-CGWLMX的博客
09-10 2897
和我的LeetCode系列源码放到一起。做IT行业，不管是测试、开发、运维等等，或简单或复杂的算法是必不可少的，也是大家面试工作中的必要环节，这个专栏开始和大家一起来研究著名的LeetCode，里边有上千种最常见的算法，面试工作出现几率很高，值得掌握研究，每次完成博客更新我会同步更新我的个人Github上的代码，每个算法都可以直接运行调试以供掌握，GitHub地址：https://github.c...
数据结构——排序算法（冒泡排序、选择排序、插入排序、归并排序、快速排序、搜索算法）
qq_52301431的博客
08-25 1147
如果有一天你面试的时候, 让你写一个排序算法, 你可以洋洋洒洒的写出多个排序算法, 但是如果其中没有快速排序, 那么证明你对排序算法也只是浅尝辄止, 并没有深入的研究过.- 对于N个数据项呢?- 如果2位置元素小于1位置的元素, 那么将0位置的元素移动到1位置, 并且将2位置的元素放在0位置, 0 - 1 - 2搞定.选择排序第一次将第0位置的人取出, 和后面的人(1, 2, 3...)依次比较, 如果后面的人更小, 那么就交换..........
归并排序，排序等算法，数据结构，快速排序，链表排序
05-27
归并排序，排序等算法，数据结构，快速排序，链表排序归并排序，排序等算法，数据结构，快速排序，链表排序
查找与排序
linlinlin45的博客
05-29 1026
查找的相关概念 查找是什么呢？ 我准备打个电话给朋友，懒得重新输入电话号码，需要查找通讯录或者通话记录； 我想买件衣服或者买双鞋，需要在网购app上搜索关键字，来查找心仪的商品； 我LOL想练一个没玩过的英雄，不知道该点什么天赋，出什么装备，需要去浏览器去查找玩法攻略； … 由此可见，查找或搜索，在我们的生活中随处可见，甚至说是必不可少的。所以我们来讲一下查找的相关概念： 在数据结构中，我们把所有被查的数据所在的集合，统称为查找表 查找表（Search Table）是 同一类型 的数据元素（或记录
常见的排序算法（直接插入&选择排序&二分查找排序）
weixin_34138056的博客
06-20 242
1、直接插入排序算法 源码： package com.DiYiZhang;/* 插入排序算法* 如下进行的是插入，排序算法*/public class InsertionSort { public static void insertionSort(int[] a) { int tmp; for (int i = 1; i < a.length; ...
常见的查找与排序
LH197318的博客
11-18 695
今天忽然回顾了一下数据结构这块 ~ 回顾了网上大神们写的，有些内容就过来了，下次回顾方便一些 ~ 常用的查找算法主要有： 顺序查找、 二分查找 顺序查找：按数据存储的顺序进行遍历查找，对存储顺序没有要求，性能较低。 二分查找：也叫折半查找，求待查找的序列有序。每次取中间位置的值与待查关键字比较，如果中间位置的值比待查关键字大，则在前半部分循环这个查找的过程，如果中间位置的值比待查关键字小，则在...
Mergesort-归并排序
码农之道
06-04 850
#include   using namespace std;   void Merge(intr[],int r1[],int s,int m,int t) { inti=s; intj=m+1; intk=s; while(i if(r[i] elser1[k++]=r[j++]; } if(i while(i else while(j for(intl=s;
算法入门＜一＞：C++各种排序算法详解及示例源码
最新发布
欧特GO
04-28 1971
算法入门＜一＞：C++各种排序算法详解及示例源码
十大经典排序算法总结（C++实现+动画）
李嘉佑的博客
08-10 2081
【C++】一文让你彻底学会排序算法（含精美动图）
C++ 九大排序和三大查找 详解（原理+代码实现，含主函数）
楚尧的博客
08-14 649
一、查找 1.二分折半查找 #include<iostream> using namespace std; //二分查找法，查找一个数组的元素，并返回所在的位置的下标， //必须要是一个有序的数组， int select_arr(int arr[], int len, int arr_value) { while (1) { int left = 0; //数组的左侧下标 int right = len-1; //数组的右侧下标
数据结构——查找与排序
weixin_46067095的博客
03-29 2941
查找 静态查找表 顺序查找(Sequential Search) 原理： 对于任意一个序列以及一个给定的元素，将给定元素与序列中元素依次比较，直到找出与给定关键字相同的元素，或者将序列中的元素与其都比较完为止。 代码实现类似于数组遍历，理解即可。 顺序查找的平均查找长度ASL = (n + 1)/2 折半查找( Binary Search ) 定义：折半查找也叫二分查找。要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。 查找过程：表中元素按照一定顺序进行排列，将需要查找的元素与表中间位置元素
算法基础：排序与查找
逍遥游
06-23 6518
1、直接插入排序 1.1、基本思想：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的；如此反复循环，直到全部排好顺序。
算法——查找和排序
zhenaoxi1077的博客
05-11 1万+
查找算法：顺序查找、二分查找、哈希表查找、二叉排序树查找。 排序算法：插入排序、冒泡排序、归并排序、快速排序等。 以下皆为转载： 原文地址： https://www.cnblogs.com/wxisme/p/5243631.html 1.1 冒泡排序： 冒泡排序是最简单的排序之一了，其大体思想就是通过与相邻元素的比较和交换来把小的数交换到最前面。这个过程类似于水泡向上升一样，因此而得...
查找与排序（Find ＆ Sort）
柳小白的博客
08-13 2902
查找 一、顺序查找：从线性表的第一个元素开始，逐个将线性表的元素与被查元素比较。在平均情况下，大约需要比较n/2次 特殊情况： ①线性表是无序表，不管是顺序存储结构还是链式存储结构，都只能用顺序查找 ②线性表是有序的，如果采用链式存储结构，只能用顺序查找 二、二分法查找 线性表条件： ①用顺序存储结构； ②线性表是有序表（元素按非递减排列）； 与中间项比较。最多比log2（n）次 排序 排序：将一个无序序列整理为按值非递减顺序排序的一种方式 逆序：序列中，如果某个元素其后存在一个元素小于它，则称存
查找和排序的基本操作：查找排序算法大集合
dengquanyan6606的博客
07-28 1593
重点 查找算法着重掌握：顺序查找、二分查找、哈希表查找、二叉排序树查找。 排序算法着重掌握：冒泡排序、插入排序、归并排序、快速排序。 顺序查找 算法说明 顺序查找适合于存储结构为顺序存储或链接存储的线性表。 算法思想 顺序查找也称为线形查找，属于无序查找算法。从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没...
理论基础 —— 排序 —— 直接选择排序
热门推荐
Alex_McAvoy的博客
02-08 7万+
【概述】 直接选择排序又称简单选择排序，是一种不稳定的排序方法，其是选择排序中最简单一种，其基本思想是：第 i 趟排序再待排序序列 a[i]~a[n] 中选取关键码最小的记录，并和第 i 个记录交换作为有序序列的第 i 个记录。 其实现利用双重循环，外层 i 控制当前序列最小值存放的数组元素位置，内层循环 j 控制从 i+1 到 n 序列中选择最小的元素所在位置 k 【排序过程】 1.排序...
几种排序和查找方法
qq_43563207的博客
07-13 2410
冒泡法排序 本题要求将给定的n个整数从小到大排序后输出。输出时相邻数字中间用一个空格分开，行末不得有多余空格。 #include <stdio.h> # define MAXN 10 int main(){ int i,j,n,temp,flag; int a[MAXN]; scanf("%d",&n); for(i=0;i<n;i++){ scanf("%d",&a[i]);
数据结构之查找和排序
JiaHao的博客
08-31 928
总结了数据结构中常见的几种查找和排序方法：顺序查找、折半查找、分块查找、直接插入排序、折半插入排序、希尔排序、简单选择排序、锦标赛排序、堆排序、冒泡排序、快速排序、归并排序...
数据结构，查找和排序（快排、直接插入排序、堆排序、散列表拉链法、折半查找）
ysatmovo的博客
06-15 2231
快排、直接插入排序、堆排序、散列表拉链法、折半查找
C++实现排序算法类全览：从插入到归并
本资源提供了多种经典的排序算法的C++类实现，包括直接插入排序、折半插入排序、Shell排序、归并排序、简单选择排序、基数排序以及堆排序等。以下将详细讲解这些排序算法的原理和C++实现。 1. **直接插入排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值