常见排序算法实现(直接插入排序,冒泡排序,快速排序,建大选择排序)

常见的排序算法实现(直接插入排序,冒泡排序,快速排序,建大选择排序),还有几个下次写上。

#include "stdio.h"
#include "stdlib.h"
#include "malloc.h"
#include <iostream>
using namespace std;
#define N 10

void showArr(int a[]);
void InsertSort(int a[]);    //直接插入排序
void BubbleSort(int a[]);    //冒泡排序
void Quicksort(int a[],int ,int);    //快速排序
void SimpleSelectionSort(int a[]);    //简单选择排序(每次选择一个与第一个交换)

int main()
{
    int a[N]={3,1,14,5,2,56,67,54,77,34};
    showArr(a);

//    InsertSort(a);    //直接插入排序
//    BubbleSort(a);    //冒泡排序
    //Quicksort(a,0,N-1);    //快速排序
    //cout<<"这是直接插入排序的结果"<<endl;
    //showArr(a);
    //cout<<endl;

    SimpleSelectionSort(a);

    system("pause");
    return 0;
}

//打印列表
void showArr(int a[N])
{
    for(int i=0;i<N;i++)
        cout<<a[i]<<" ";
    cout<<endl;
}

//直接插入排序
void InsertSort(int a[N])
{
    int tmp;
    int j;
    for(int i=1;i<N;i++)
        if(a[i]<a[i-1])
        {
            tmp=a[i];    //将这个值暂存在tmp中
            for(j=i-1;tmp<a[j];j--)
                a[j+1]=a[j];    //前面覆盖后面的值
            a[j+1]=tmp;
        }
    cout<<"这是直接插入排序的结果"<<endl;
    showArr(a);
    cout<<endl;

}

//冒泡排序
void BubbleSort(int a[N])
{
    int tmp;
    for(int i=0;i<N;i++)
        for(int j=0;j<N-i-1;j++)
        {
            if(a[j]>a[j+1])
            {
                tmp=a[j];
                a[j]=a[j+1];
                a[j+1]=tmp;
            }
        }
    cout<<endl<<"这是冒泡排序的结果"<<endl;
    showArr(a);
    cout<<endl;
}

//快速排序
void Quicksort(int a[],int left,int right)
{

    if(left<right)
    {
        int i=left,j=right,tmp=a[i];//每次以第一个元素为基点排序,小的在前,大的在后面
        while(i<j)
        {
            while(i<j && a[j]>tmp)
                j--;
            if(i<j)
                a[i++]=a[j];
            while(i<j && a[i]<=tmp)
                i++;
            if(i<j)
                a[j--]=a[i];
        }
        a[i]=tmp;    //完成第一次快度排序,放入它最终的位置
        Quicksort(a,left,i-1);        //前面按相同的方法递归快速排序
        Quicksort(a,i+1,right);        //后面按相同的方法递归快速排序
    }
}
//简单选择排序
void SimpleSelectionSort(int a[])
{
    int min;
    int tmp;    //临时变量
    for(int i=0;i<N-1;i++)
    {
        min=i;    //首先暂定min为开始的那个元素
        for(int j=i+1;j<N;j++)
            if(a[j]<a[min])
                min=j;    //找到最小的值 
        tmp=a[min];        //与第一个元素交换
        a[min]=a[i];
        a[i]=tmp;
    }
    cout<<endl<<"这是选择排序的结果"<<endl;
    showArr(a);
    cout<<endl;
}

运行结果:

3 1 14 5 2 56 67 54 77 34
这是选择排序的结果
1 2 3 5 14 34 54 56 67 77
请按任意键继续. . .
时间: 2024-08-01 22:46:30

常见排序算法实现(直接插入排序,冒泡排序,快速排序,建大选择排序)的相关文章

排序算法第一篇(简单桶排、选择排序、冒泡排序、快速排序)

简单桶排序 1 /** 2 * @author: 攻城狮小白 3 * @creationTime:2017年11月24日 下午10:37:59 4 * @description: 桶排序(这个不是真正的桶排,真正的桶排比这个稍微复杂些.但是是桶排的思想,就叫它简单桶排吧) 5 * @questionDesc:一个班上有6名同学,考试成绩如下arr数组(满分10分),如何快速将学生成绩从小到大排列? 6 */ 7 public class BucketSortDemo { 8 public voi

经典(java版)排序算法的分析及实现之三简单选择排序

选择排序-简单选择排序 选择排序的基本思想是:每一趟从待排序的记录中选出关键字最小的记录,顺序放在已排好序的子系列的最后,直到全部记录排序完毕.简单选择排序也叫直接选择排序. 基本算法: 将给定待排序序列A[0....n],第一次从A[0]~A[n-1]中选取最小值,与A[0]交换,第二次从A[1]~A[n-1]中选取最小值,与A[1]交换,....,第i次从A[i-1]~A[n-1]中选取最小值,与A[i-1]交换,.....,第n-1次从A[n-2]~A[n-1]中选取最小值,与A[n-2]

冒泡排序Vs直接选择排序

什么是排序?为什么要使用排序?其实我们生活中处处都用到了排序,拿字典来说,现在,我们要在字典中查找某个字(已经知道这个字的读音),首先,我们需要根据这个字的读音,找到它所所在目录中的位置,然后根据这个字的所在页数准确的定位到这个字的位置. 在查找字的过程中,我们注意到了这样的字眼,根据读音找到...位置,根据页数定位这个字的位置,我们在无意识的情况下,使用到了排序和查找,字典的编写者对整部字典进行了排序,我们的工作就是根据字典的排序方法查找某个记录.下面详细的介绍排序的相关内容. 排序是一个处理

七大内部排序算法总结(插入排序、希尔排序、冒泡排序、简单选择排序、快速排序、归并排序、堆排序)

 写在前面: 排序是计算机程序设计中的一种重要操作,它的功能是将一个数据元素的任意序列,重新排列成一个按关键字有序的序列.因此排序掌握各种排序算法非常重要.对下面介绍的各个排序,我们假定所有排序的关键字都是整数.对传入函数的参数默认是已经检查好了的.只是简单的描述各个算法并给出了具体实现代码,并未做其他深究探讨. 基础知识: 由于待排序的记录数量不同,使得排序过程中设计的存储器不同,可将排序方法分为两大类:一类是内部排序,指的是待排序记录存放在计算机随机存储器中进行的排序过程.另一类是外部排序,

常用排序算法实现[交换排序之冒泡排序、快速排序]

相关知识 1. 稳定排序和非稳定排序: 稳定排序算法会依照相等的关键(换言之就是值)维持纪录的相对次序. 如果排序算法是稳定的,就是当有两个有相等关键的纪录R和S,且在原本的列表中R出现在S之前,在排序过的列表中R也将会是在S之前. 2. 内排序和外排序 在排序过程中,所有需要排序的数都在内存,并在内存中调整它们的存储顺序,称为内排序: 在排序过程中,只有部分数被调入内存,并借助内存调整数在外存中的存放顺序排序方法称为外排序. 3.算法分类 排序算法从理论上分为如下几类: (1) 交换排序法:

排序算法学习之简单排序(冒泡排序,简单选择排序,直接插入排序)

一.冒泡排序 冒泡排序算是最基础的一种算法了,复杂度为O(N^2),其基本思想是:从最低端数据开始,两两相邻比较,如果反序则交换.代码如下: /*最基本的冒泡排序*/ void BubbleSort1 (int n, int *array) /*little > big*/ { int i, j; for (i=0; i<n-1; i++) { for (j=n-1; j>i; j--) { if (array[j] < array[j-1]) { int temp = array

java 排序算法(一) 冒泡排序、快速排序

冒泡排序 冒泡排序是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端. 冒泡排序的算法实现如下:[排序后,数组从小到大排列] /** * 冒泡排序 * 比较相邻的元素.如果第一个比第二个大,就交换他们两个. * 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应该会是最大的

排序算法之 Java插入排序算法

package net.qh.test.sort; import java.util.ArrayList; import java.util.Calendar; import java.util.List; /** * Created by Administrator on 2016/03/01. */ public class Insert { public int[] sort(int[] arr){ if ( arr == null || arr.length <= 1 ){ return

排序(二)__冒泡排序、简单选择排序和直接插入排序

前面<排序(一)__综述>提到按照算法的复杂度分为简单算法和改进算法两大类,本文主要就简单算法中的冒泡排序.简单选择排序和直接插入排序进行通俗详细的解析. 一.冒泡排序 1.基本概念 冒泡排序是一种交换排序,它的基本思想是:两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止.(动态图来自维基百科) 2.关键代码(优化之后) void BubbleSort(SqList *L) { int i,j; Status flag=TRUE;            //flag用作标记,避