几种常见简单排序算法

- 简单选择排序

循环遍历整个数组,每次遍历都是从当前待填充位置开始,找出未排序集合中的最小值,每次找到更小值都记录其值和位置信息,遍历完成后,将最小值与当前待填充点 进行交换。继续下一个位置,直到外循环到达数组尾。

#include <iostream>
using namespace std;
int main()
{
    int a[10]={23,11,6,33,14,99,23,2,14,20};
    int smallest;
    int smallpos;
    for(int i=0;i<10;i++)
    {
        cout<<a[i]<<‘ ‘;
    }
    for(int i=0;i<9;i++)
    {
        smallest=a[i];
        smallpos=i;
        for(int j=i+1;j<10;j++)
        {
            if(a[j]<smallest)
            {
                smallest=a[j];
                smallpos=j;
            }
        }
        a[smallpos]=a[i];
        a[i]=smallest;
    }
    cout<<endl;
    for(int i=0;i<10;i++)
    {
        cout<<a[i]<<‘ ‘;
    }
    return 1;
}

- 插入排序

插入排序的原理为在未排序集合中选择一个值在已排序集合中寻找其合适的位置插入。首先整个集合默认为未排序集合,从头开始遍历,得到一个未排序数据并记录,然后从该数据位置开始往回遍历寻找插入位置,首先判断待插入位置是否为首位,如果是则直接插入。否则,每次将待插入值与待插入位置前一位的值相比,若比待插入值大,则该值往后移动一位,待插入位置前移一位,否则将待插入值填入待插入位置。

#include <iostream>
using namespace std;
/******插入排序***********/
int main()
{
    int a[10]={23,11,6,33,14,99,23,2,14,20};
    int cur;
    for(int i=0;i<10;i++)
    {
        cout<<a[i]<<‘ ‘;
    }
    cout<<endl;
    for(int i=1;i<10;i++)
    {
        cur=a[i];
        for(int j=i;j>=0;j--)
        {
            if(j==0)
            {
                a[j]=cur;
            }
            else if(a[j-1]>cur)
            {
                a[j]=a[j-1];
            }
            else
            {
                a[j]=cur;
                break;
            }
        }
     }
    for(int i=0;i<10;i++)
    {
        cout<<a[i]<<‘ ‘;
    }
    return 1;
}

-交换排序

循环遍历数组,每次比较相邻两个元素,将大的放在后面,小的放在前面,直到达到最后交换元素位置,每次达到最后交换元素位置并完成交换后,就将最后交换元素位置前移一位。直至最后交换元素位置与首位重合,则排序结束,退出循环。

下面程序中last表示最后交换元素的位置。

#include <iostream>
using namespace std;
/*******交换排序***********/
int main()
{
    int a[10]={23,11,6,33,14,99,23,2,14,20};
    int last=9;
    for(int i=0;i<10;i++)
    {
        cout<<a[i]<<‘ ‘;
    }
    cout<<endl;
    while(last>0)
    {
        for(int i=0; i < last; i++ )
        {
            if(a[i]>a[i+1])
            {
                int tmp=a[i];
                a[i]=a[i+1];
                a[i+1]=tmp;
            }
        }
        last--;
    }
    for(int i=0;i<10;i++)
    {
        cout<<a[i]<<‘ ‘;
    }
    return 1;
}

-归并排序

其原理是,将两个有序集合同时遍历,每次比较两个集合中当前位置的元素,将较小的元素赋给合并集合相应位置,然后合并集合待填充位置右移一位,较小元素所在集合当前位置右移一位,继续比较,同时还需要判断哪个集合先遍历完,对于另外一个还有剩余元素的集合,则直接把剩余的元素直接赋给合并集合剩余的位置中。但是由于集合是乱序的,因而需要将集合不断分割至单元素集合(可认为是有序集合),然后再进行集合的的重新组合,组合得到的新集合则是有序的,如此回溯直至回到从原始集合中分开的两个子集为有序集合,再进行最后一次合并,完成原始集合的排序。

总体而言,其步骤是递归地分割原始集合,直至集合中只有单元素,然后往回结合成有序集合,即排序的过程是从下往上的。

#include <iostream>
using namespace std;
int mergesort(int* array,int i,int j);
int merge(int* arr,int i,int  k,int j);
int main()
{
    int a[10]={23,11,6,33,14,99,23,2,14,20};
    int n=9;
    for(int i=0;i<=n;i++)
    {
        cout<<a[i]<<‘ ‘;
    }
    cout<<endl;
    mergesort(a,0,n);
    for(int i=0;i<=n;i++)
    {
        cout<<a[i]<<‘ ‘;
    }
    return 1;
}
int mergesort(int* array,int i,int j)
{
    if(i<j)
    {
        int k=(i+j)/2 ;
        mergesort(array,i,k);
        mergesort(array,k+1,j);
        merge(array,i,k,j);
    }
    return 0;
}
int merge(int* arr,int i,int k,int j)
{
    int ipos=i;
    int kpos=k+1;
    int mpos=0;
    int* tmparr=new int[j-i+1];
    while(ipos<=k || kpos<=j)
    {
        if(ipos>k)            //表示左集合数据合并完毕
        {
            while(kpos<=j)
            {
                tmparr[mpos]=arr[kpos];
                kpos++;
                mpos++;
            }
            continue;
        }
        else if(kpos>j)        //右集合数据合并完毕
        {
            while(ipos<=k)
            {
                tmparr[mpos]=arr[ipos];
                ipos++;
                mpos++;
            }
            continue;
        }
        if(arr[ipos]<arr[kpos])
        {
             tmparr[mpos]=arr[ipos];
             ipos++;
             mpos++;
        }
        else
        {
            tmparr[mpos]=arr[kpos];
            kpos++;
            mpos++;
        }
    }
    ipos=i;
    int tmpi=0;
    while(ipos<=j)
    {
        arr[ipos]=tmparr[tmpi];
        ipos++;
        tmpi++;
    }
    delete tmparr;
    return 0;
}

图中箭头序号表示的是执行顺序,实现框为原始数据顺序,虚线框为排序过后顺序。

-快速排序

快速排序与归并排序有点相似,都是需要分割,但是其过程却是相反的,归并排序是先分割,然后回溯时候进行排序,当回溯到原集合的时候完成排序。而快速排序是先排序(确定基准元素位置,以及其他元素所处集合)然后分割,再确定分割后的集合中基准元素位置,递归进行,当分割至最后一个元素则意味着最后一个元素的位置确定了,即整个集合完成排序。

#include <iostream>
using namespace std;

int qsort(int* array,int l,int r);
int sort(int* array,int lp,int rp);

int main()
{
    int a[10]={23,11,6,33,14,99,23,2,14,20};
    for(int i=0;i<10;i++)
    {
        cout<<a[i]<<‘ ‘;
     }
     cout<<endl;
    qsort(a,0,9);
    for(int i=0;i<10;i++)
    {
        cout<<a[i]<<‘ ‘;
    }
    return 1;
}

int qsort(int* array,int l,int r )
{
    int pos;
    if(l<r)
    {
        pos=sort(array,l,r);
        qsort(array,l,pos-1);
        qsort(array,pos+1,r);
    }
}

int sort(int* array,int lp,int rp)
{
    int lpos=lp;
    int rpos=rp;
    int pivot=array[lp];
    while(lpos<rpos)
    {
        while(array[rpos]>pivot)
                rpos--;
        while( (lpos<rpos) && array[lpos]<=pivot)
        {
                lpos++;
        }
        if(lpos<rpos)
        {
            int tmp=array[lpos];
            array[lpos]=array[rpos];
            array[rpos]=tmp;
            lpos++;
            rpos--;
            continue;
        }
     }
     array[lp]=array[rpos];
     array[rpos]=pivot;
     return rpos;
}
时间: 2024-10-06 00:53:24

几种常见简单排序算法的相关文章

几种常见的排序算法

1.插入类排序 在一个已经有序的序列中,插入一个新的记录.有直接插入排序.折半插入排序.希尔排序. 插入类排序 直接插入排序 1 void InsertSort(int R[], int n) 2 { 3 int i, j; 4 int temp; 5 for (i = 1; i < n; ++i) 6 { 7 temp = R[i]; 8 j = i - 1; 9 while (j >= 0 && temp < R[j]) 10 { 11 R[j+1] = R[j];

java几种常见的排序算法总结

[java] view plain copy /*************几种常见的排序算法总结***************************/ package paixu; public class PaiXu { final int MAX=20; int num[]=new int[MAX]; { System.out.print("生成的随机数组是:"); for(int i=0;i<20;i++){ num[i]=(int)(Math.random()*100)

Python全栈开发之5、几种常见的排序算法以及collections模块提供的数据结构

在面试中,经常会遇到一些考排序算法的题,在这里,我就简单了列举了几种最常见的排序算法供大家学习,说不定以后哪天面试正好用上,文章后半段则介绍一下collections模块,因为这个模块相对于python提供的基本数据结构(list,tuple,dict)不被人们所熟悉,但是如果你对他们了解的话,用起来也是非常方便高效的. 排序算法 一.冒泡排序(BubbleSort) 步骤: 比较相邻的元素,如果第一个比第二个大,就交换他们两个. 循环一遍后,最大的数就“浮”到了列表最后的位置. 将剩下的数再次

几种常见的排序算法分析学习

目录(?)[-] 冒泡排序 选择排序 1 直接插入排序 1 二分查找插入排序 希尔入排序 快速排序 归并排序 总结 本篇博客知识点 分别描述了 冒泡,选择,直接插入,二分插入,希尔,快速以及归并排序.同时还有Java实现代码,算法分析和示意图 冒泡排序 算法描述 设待排序记录序列中的记录个数为n 一般地,第i趟起泡排序从1到n-i+1 依次比较相邻两个记录的关键字,如果发生逆序,则交换之. 其结果是这n-i+1个记录中,关键字最大的记录被交换到第n-i+1的位置上,最多作n-1趟. 算法实例 经

七种常见经典排序算法总结(C++)

最近想复习下C++,很久没怎么用了,毕业时的一些经典排序算法也忘差不多了,所以刚好一起再学习一遍. 除了冒泡.插入.选择这几个复杂度O(n^2)的基本排序算法,希尔.归并.快速.堆排序,多多少少还有些晦涩难懂,幸好又博客园大神dreamcatcher-cx都总结成了图解,一步步很详细,十分感谢. 而且就时间复杂度来说,这几种算法到底有什么区别呢,刚好做了下测试. 代码参考: http://yansu.org/2015/09/07/sort-algorithms.html //: basic_so

java基础之几种常见的排序算法

一,冒泡排序 1.原理: 从数组的第一个位置开始两两比较array[index]和array[index+1],如果array[index]大于array[index+1]则交换array[index]和array[index+1]的位置,止到数组结 束: 从数组的第一个位置开始,重复上面的动作,止到数组长度减一个位置结束: 从数组的第一个位置开始,重复上面的动作,止到数组长度减二个位置结束: ....... 2. 时间复杂度:O(N2),进行了(n-1)*(n-2)....=n*(n-1)/2

几种常见的排序算法Java实现总结

public class MySort { final int MAX=20; int num[]=new int[MAX]; { System.out.print("生成的随机数组是:"); for(int i=0;i<20;i++){ num[i]=(int)(Math.random()*100); System.out.print(num[i]+" "); } System.out.println(); } int num2[]=new int[MAX]

几种常见的排序算法总结

*****选择排序***** 方法描述:首先找到第一个最小的数,和第一个数交换:然后从剩下的找出最小的与第二个交换,以此类推.效率: 长度为N的数组,大约N2/2比较,N次交换特点: 1.运行时间和输入无关,有序数组,全部相等的数组,随机数组所用时间一样,没有充分利用输入的初始状态. 2.数据移动最少,与输入成线性关系.代码: sort(int[] a){ int n = a.length; for(int i = 0; i < n; i++){ int min = i; for(int j =

用Java实现几种常见的排序算法

用Java语言实现的各种排序,包括插入排序.冒泡排序.选择排序.Shell排序.快速排序.归并排序.堆排序.SortUtil等. 插入排序: package org.rut.util.algorithm.support; import org.rut.util.algorithm.SortUtil; /** * @author treeroot * @since 2006-2-2 * @version 1.0 */ public class InsertSort implements SortU