排序算法实现分析

原创 2016年06月01日 20:52:08

排序算法分析


选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法。
冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。

冒泡法:这是最原始,也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡:复杂度为O(n*n)。当数据为正序,将不会有交换。复杂度为O(0)。

直接插入排序:O(n2)

选择排序:O(n2)

快速排序:平均时间复杂度nlog2(n),所有内部排序方法中最高好的,大多数情况下总是最好的。

归并排序:nlog2(n)

堆排序:nlog2(n)

希尔排序:算法的复杂度为n的1.2次幂

#include<iostream>
#include<cassert>
#include <algorithm> 
using namespace std;
void insertion_sort(int a[], int n)//insertion sort
{
    assert(a != NULL );
    int temp;
    int j = 0;
    for (int p = 1; p < n; ++p)
    {
        temp = a[ p];
        for ( j = p; j > 0 && a[j - 1 ]>temp; --j)
        {
            a [j] = a[j - 1 ];
        }
        a [j] = temp;
    }
}
// bubble sort 的改进版,一旦没发生交换则排序结束, flag去掉则为原始版本。
void bubble_sort(int a[], int n)
{
    assert(a != NULL );
    int i, j ,flag= 1;
    for (i = 0 ; i < n - 1 && flag; ++i)
    {
        flag = 0 ;
        for ( j = 0; j < n - 1 - i;++j )
            if ( a[j]>a [j + 1 ])
            {
                swap (a[ j], a[j + 1 ]);
                flag = 1 ;
            }
    }
}
void selection_sort(int a[], int n)//selection sort
{
    assert(a != NULL );
    int i, j , min;
    for (i = 0 ; i < n; ++i )
    {
        min = i;
        for ( j = i + 1; j < n;++ j)
            if ( a[j] < a[ min])
                min = j;
            if(min != i)
               swap (a[ min], a [i]);
    }
}
int partition(int a[], int start, int end) //partition 算法
{
    assert(a != NULL );
    int middle = ( start + end ) / 2 ;
    int pivotIndex ;
    if (a[ start] < a[ middle])
        if ( a[middle] < a[ end])
            pivotIndex = middle;
        else if (a[start ] < a[end])
            pivotIndex = end;
        else
            pivotIndex = start;
    else if ( a[start] <a[ end])
        pivotIndex = start;
    else if ( a[middle]<a [end])
        pivotIndex = end;
    else
        pivotIndex = middle;
    int pivot = a[ pivotIndex];
    swap(a [pivotIndex], a[end ]);
    int storeIndex = start;
    for (int i = start ; i < end; ++i)
    {
        if ( a[i]<pivot )
        {
            swap (a[ i], a[storeIndex ]);
            ++storeIndex;
        }
    }
    swap(a [storeIndex], a[end ]);
    cout << pivot << endl;
    return storeIndex ;
}
void quick_sort(int a[], int left, int right) //quick sort
{
    if (left == right)
        return;
    int index = partition(a, left , right);
    if (index > left)
        quick_sort (a, left, index - 1 );
    if (index < right)
        quick_sort (a, index+1 , right);
}
//归并排序的merge相当于两个已排序链表或者数组的合并
void merge( int arr[], int temp_arr[], int start_index, int mid_index , int end_index)
{
    int i = start_index , j = mid_index + 1;
    int k = 0;
    while (i < mid_index + 1 && j < end_index + 1)
        temp_arr [k++] = arr[i ] > arr[j ] ? arr[j ++] : arr[i ++];
    while (i < mid_index+1 )
        temp_arr [k++] = arr[i ++];
    while (j < end_index+1 )
        temp_arr [k++] = arr[j ++];
    for (i = 0 , j = start_index; j < end_index+1; i ++, j++)
        arr [j] = temp_arr[i ];
}
void merge_sort(int a[], int temp_a[], int start_index, int end_index )
{
    if (start_index == end_index)
        return;
    int mid_index = ( start_index + end_index ) / 2 ;
    merge_sort(a , temp_a, start_index, mid_index );
    merge_sort(a , temp_a, mid_index + 1, end_index );
    merge(a , temp_a, start_index, mid_index , end_index);
}
void heap_adjust(int a[], int i, int len)//heap sort
{
    int child ;
    int temp;
    for (; 2 * i + 1 < len; i = child )
    {
        child = 2 * i + 1;
        if(child <len - 1 && a[child + 1 ] > a[child])
            ++child;
        if ( a[i] < a[ child])
        {
            temp = a[ i];
            a [i] = a[child ];
            a [child] = temp;
        }
        else
            break;
    }
}
void heap_sort(int a[], int len)
{
    assert(a != NULL );
    int i;
    for ( i = len / 2; i >= 0 ; -- i)
        heap_adjust (a, i,len);
    for (i = len - 1; i > 0 ; -- i)
    {
        int tmp = a[0];
        a [0] = a[i ];
        a [i] = tmp;
        heap_adjust (a, 0 , i);
    }
}
//shell sort,中间两个循环的思想和插入排序一样,每次相当于对 incur个子数组进行排序
void shell_sort(int a[], int len)
{
    int i, j , incr;
    int temp;
    for (incr = len / 2; incr > 0 ; incr /= 2 )
    {
        for ( i = incr; i < len; i++)
        {
            temp = a[ i];
            for ( j = i; j >= incr && a[j - incr ]>temp; j -= incr )
                a [j] = a[j - incr];
            a [j] = temp;
        }
    }
}
int main() {
    int arr[] = { 61 , 17 , 29 , 22 , 34 , 60 , 72 , 21 , 50 , 1 , 62 };
    int len = (int) sizeof(arr) / sizeof(*arr);
    cout << len << endl;
    int *temp_a = new int [len];
    merge_sort(arr ,temp_a, 0,len -1);
    delete[]temp_a;
    for (int i = 0; i < len; i++)
        cout << arr[ i] << ' ';
    cout << endl ;
    return 0;
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

几种排序算法实现分析

合并排序 void merge(int a[],int left,int mid,int right,int b[]) { int i = left; int j = m...
  • qbg19881206
  • qbg19881206
  • 2013年06月30日 23:09
  • 618

排序算法实现及分析

所谓排序,就是要整理文件中的记录,使之按关键字递增(或递减)次序排列起来。其确切定义如下:   输入:n个记录R1,R2,…,Rn,其相应的关键字分别为K1,K2,…,Kn。   输出:Ril...
  • wuzhekai1985
  • wuzhekai1985
  • 2011年07月15日 11:00
  • 1938

7种排序算法实现及分析

所谓排序,就是要整理文件中的记录,使之按关键字递增(或递减)次序排列起来。其确切定义如下:   输入:n个记录R1,R2,…,Rn,其相应的关键字分别为K1,K2,…,Kn。   输出:R...
  • u013239665
  • u013239665
  • 2014年10月07日 07:23
  • 343

排序算法实现以及比较

本文介绍了常用的内排序算法包括比较排序算法(插入排序、冒泡排序、选择排序、快速排序、归并排序、堆排序)和基于运算的排序算法(基数排序、桶排序)。分别对这些算法从算法思想、伪代码、复杂度和稳定性、算法的...
  • zhangph1229
  • zhangph1229
  • 2016年07月31日 19:33
  • 1023

各种排序算法--c++实现

#include using namespace std; //堆排序 void FindMaxInHeap(int arr[], int size) { for (int j = ...
  • woailvmengmeng
  • woailvmengmeng
  • 2014年04月10日 15:26
  • 968

各类排序算法的对比及实现

(直接插入排序,希尔,选择排序,堆排序,冒泡排序,快排,归并)各类排序的算法比较及实现...
  • wangiijing
  • wangiijing
  • 2016年05月23日 23:29
  • 2415

数据结构复习:几种排序算法的C++实现和二叉树的相关算法实现

      用c语言实现了二叉树的数据定义,二叉树的构建、销毁,以及先序、中序、后序的递归算法,非递归算法正在研究中。/*---------------------------------------...
  • yysdsyl
  • yysdsyl
  • 2007年11月14日 21:58
  • 3478

【算法C++】烙饼排序

问题描述: 把一摞大小不一的烙饼按顺序排好,大的在下面,小的在上面, 要求只能用一只手去翻转烙饼位置,另一只手要端盘子; 输出最优化的排序过程。示例: 3 1 2 翻转 1 , 当前烙饼排序...
  • zgljl2012
  • zgljl2012
  • 2015年09月28日 23:36
  • 1880

排序算法实现

对本文出现的排序算法的分析见http://blog.csdn.net/libinjlu/article/details/12859211 1.插入排序 template void insertion...
  • coolibin
  • coolibin
  • 2013年10月24日 10:56
  • 728

数据结构——排序查找算法实现

前面转载了一篇讲排序算法的文章,这几天将排序和查找算法进行了实现,在这里贴出代码来。...
  • u010757264
  • u010757264
  • 2016年08月18日 16:13
  • 471
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:排序算法实现分析
举报原因:
原因补充:

(最多只允许输入30个字)