排序方法总结和实现

由于很多大神已经总结过各种排序算法的性能及适合坏境,这里便不再总结,只是强调几个重点。

(1)快排的空间复杂度不是o(1),是o(logn)~o(n);

(2)四种不稳定的排序算法:简单选择,快排,希尔和堆排序

(3)冒泡排序最有情况下时间复杂度可优化为o(n);

(4)归并排序的空间复杂度为o(n);

(5)快排在整体倒序的情况下时间复杂度为o(n2)

(6)建一个最大堆的复杂度为o(n):具体证明可参考算法导论相关章节

(7)本文代码的归并排序的范围是[   )

(8)本文代码的堆排序为了方便从a[1]开始

(9)在添加了语句using namespace std;语句之后,swap函数才可以使用

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
using namespace std;

void print(int *number, int length)
{
    if(number == NULL || length < 1)
        return;

    for(int i = 0; i < length; ++i)
    {
        printf("%d ", number[i]);
    }

    printf("\n");
}

void SelectSort(int number[], int length)
{
    if(number == NULL || length < 1)
        return;

    for(int i = 0; i < length - 1; ++i)
    {
        int k = i;
        for(int j = i + 1; j < length; ++j)
        {
            if(number[k] > number[j])//注意大小于号
                k = j;
        }
        if(k != i)
        {
            swap(number[k], number[i]);
        }
    }
}

void BubbleSort(int number[], int length)
{
    if(number == NULL || length < 1)
        return;

    for(int i = 1; i < length; ++i)
    {
        for(int j = 0; j < length - i; ++j)
            if(number[j] > number[j + 1])
                swap(number[j], number[j + 1]);
    }
}

void InsertSort(int *number, int length)
{
    if(number == NULL || length < 1)
        return;

    for(int i = 1; i < length; ++i)
    {
        int tmp = number[i];
        int j;                   //在外面定义
        for(j = i - 1; j >= 0; j--)
        {
            if(number[j] > number[i])//比较的顺序别弄错了
                number[j + 1] = number[j];//最好检查一下
            else
                break;
        }

        number[j+1] = tmp;
    }
}

void ShellSort(int number[], int length)
{
    if(number == NULL || length < 1)
        return;

    int i, j, d;
    d = length/2;

    while(d >= 1)
    {
        for(i = d; i < length; ++i)
        {
            int tmp = number[i];
            for(j = i - d; j >= 0; j -= d)
            {
                if(number[j] > number[i])
                    number[j + d] = number[j];
                else
                    break;
            }
            number[j + d] = tmp;
        }
        d /= 2;
    }
}

int partion(int number[], int length, int start, int end)
{
    if(number == NULL || length < 1 || start < 0 || end >= length)
        return -1;

    int small = start - 1;
    for(int index = start; index < end; ++index)
    {
        ++small;
        if(number[index] < number[end])
        {
            if(small != index)
                swap(number[small], number[index]);
        }
    }
    ++small;
    swap(number[small], number[end]);

    return small;
}
void QuickSort(int number[], int length, int start, int end)// [start, end]
{
    if(number == NULL || length < 1)
        return;

    if(start == end)
        return;

    int index = partion(number, length, start, end);
    if(index > start)
        QuickSort(number, length, start, index - 1);
    if(index < end)
        QuickSort(number, length, index + 1, end);
}

void MergeSort(int number[], int length, int start, int end, int tmp[])//[start, end)
{
    if(number == NULL || length < 1 || start < 0 || end < 1)
        return;

    //int middle = start + (end - start)/2;
    if(end - start > 1)//while(start < end)
    {
       int middle = start + (end - start)/2;
       int p = start;
       int q = middle;
       int i = start;
       MergeSort(number, length, start, middle, tmp);
       MergeSort(number, length, middle, end, tmp);

       while(p < middle || q < end)
       {
           if(q >= end || (p < middle && number[p] < number[q]))// q < end
                tmp[i++] = number[p++];
           else
               tmp[i++] = number[q++];
       }

       for(int index = start; index < end; ++index)
           number[index] = tmp[index];
    }
}

void AjustHeap(int number1[], int i, int size)
{
    if(number1 == NULL || i < 1 || size < 1)
        return;

    int leftChild = 2 * i;
    int rightChild = 2 * i + 1;
    int max = i;

    if(i <= size/2 )// max <= size 是错的
    {
        if(leftChild <= size && number1[leftChild] > number1[max])
            max = leftChild;
        if(rightChild <= size && number1[rightChild] > number1[max])
            max = rightChild;
        if(max != i)
        {
            swap(number1[max], number1[i]);
            AjustHeap(number1, max, size);
        }

    }

}
void BuildMaxHeap(int number1[], int size)
{
    if(number1 == NULL || size < 1)
        return;

    for(int i = size/2; i >= 1; --i)
        AjustHeap(number1, i, size);
}
void HeapSort(int number1[], int size)
{
    if(number1 == NULL || size < 1)
        return;

    BuildMaxHeap(number1, size);

    for(int i = size; i >= 1; --i)
    {
        swap(number1[1], number1[i]);
        AjustHeap(number1, 1, i - 1);
    }
}
int main()
{
    int number[10] = {3, 5, 2, 10, 4, 1, 8, 7, 6, 9};
    //简单选择排序
    SelectSort(number, 10);
    print(number, 11);
    //冒泡排序
    BubbleSort(number, 10);
    print(number, 10);
    //插入排序
    InsertSort(number, 10);
    print(number, 10);
    //希尔排序
    ShellSort(number, 10);
    print(number, 10);
    //快速排序
    QuickSort(number, 10, 0, 9);
    print(number, 10);

    //归并排序
    int tmp[10];
    MergeSort(number, 10, 0, 10, tmp);
    print(number, 10);
    //堆排序,为了方便,堆排序从a[1]开始
    int number1[11] = {0, 3, 5, 2, 10, 4, 1, 8, 7, 6, 9};
    HeapSort(number1, 10);
    print(number1, 10);
    printf("%d\n",number1[10]);
    return 0;
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-10-18 22:44:37

排序方法总结和实现的相关文章

【学习ios之路:Objective-C】OC中常用的系统排序方法

①.OC中常用排序方法: 1).不可变数组 - (NSArray *)sortedArrayUsingSelector:(SEL)comparator; - (NSArray *)sortedArrayUsingComparator:(NSComparator)cmptr; 2)可变数组 - (void)sortUsingSelector:(SEL)comparator; - (void)sortUsingComparator:(NSComparator)cmptr; 3).字典排序 - (NS

Java实现几种常见排序方法

转自:http://www.cnblogs.com/sevenyuan/archive/2009/12/04/1616897.html 日常操作中常见的排序方法有:冒泡排序.快速排序.选择排序.插入排序.希尔排序,甚至还有基数排序.鸡尾酒排序.桶排序.鸽巢排序.归并排序等. 冒泡排序是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经

Java几种常用的实现排序方法

import java.util.Random; public class NumberSort{ /** * 私有构造方法,禁止实例化 */ private NumberSort(){ super(); } /** * 冒泡排序 * 比较相邻的元素.如果第一个比第二个大,就叫唤他们两个位置. * 对每一组相邻的元素作同样的工作,从开始的第一对到结束后的最后一对,这样剩下的最后一个应该是最大的数. * 针对所有元素重复以上操作,除了最后一个. * 持续对越来越少的数进行以上的操作,直到没有任何一

简单排序方法

排序: 排序(Sort)是计算机程序设计中的一种重要操作,也是日常生活中经常遇到的问题.例如,字典中的单词是以字母的顺序排列,否则,使用起来非常困难.同样,存储在计算机中的数据的次序,对于处理这些数据的算法的速度和简便性而言,也具有非常深远的意义. 基本概念: 排序是把一个记录(在排序中把数据元素称为记录)集合或序列重新排列成按记录的某个数据项值递增(或递减)的序列. 下表是一个学生成绩表,其中某个学生记录包括学号.姓名及计算机文化基础.C 语言.数据结构等课程的成绩和总成绩等数据项.在排序时,

c#实现几种排序方法

插入排序 1.简介 插入排序(Insertion Sort)的算法描述是一种简单直观的排序算法.它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入.插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间. 2.算法描述 一般来说,插入排序都采用in-place在数组上实现.具体算法描述如下:1.从第一个元素开始,该元素可以认为已经被排序2.

数组重排序方法

今天在复习的过程中,发现自己对数组的重排序方法sort()一直存在一个误区,重新捋顺,在此记录... 数组中存在两个可以直接用来重排序的方法:reverse()和sort(),reverse()方法就是反转数组项的顺序.在默认情况下,sort()方法按升序排列数组项,在这个过程中sort方法会调用每个数组项的toString()转型方法,然后比较得到的字符串,然后确定排序.之前一直没有注意到这一点,一直以为调用sort()方法过后会直接对一个数组进行正确排序,其实并不是这样,而是对得到的字符串进

JavaScript高级程序设计--对象,数组(栈方法,队列方法,重排序方法,迭代方法)

1.使用对象字面量定义对象 var person={}; 使用这种方式创建对象时,实际上不会调用Object构造函数. 开发人员更喜欢对象字面量的语法. 2.有时候需要传递大量可选参数的情形时,一般来讲使用对象字面量来封装多个可选参数. 3.对象属性的点表示法与方括号表示法的区别 (1)功能上:两者没区别 (2)但是方括号的有点是可以通过变量来访问属性 例如: var person={ name:"Nic" } 点表示法:person.name 方括号表示法:var prop=“nam

Array的队列方法&amp;重排序方法—— JS学习笔记2015-6-27(第68天)

队列方法 相对于栈数据结构的后进先出[LIFO]访问规则,队列数据结构的访问规则是先进先出[FIFO] 这里提到一个方法  shift(); 它能够移除数组中的第一个项,并返回该项,同时将数组长度减1:// 有点像pop() 实例: var colors = ['red','green']; var item = colors.shift(); alert(colors);  // green alert(item);  // red alert(colors.length)  // 1; 同时

Python学习——数据排序方法

Python对数据排序又两种方法: 1. 原地排序:采用sort()方法,按照指定的顺序排列数据后用排序后的数据替换原来的数据(原来的顺序丢失),如: >>> data1=[4,2,6,432,78,43,22,896,42,677,12] >>> data1.sort() >>> data1 #原来的顺序被替换 [2, 4, 6, 12, 22, 42, 43, 78, 432, 677, 896] 2. 复制排序:采用sorted()内置函数,按照

数组的查找和排序方法

数组的排序方法:reverse() 反转数组元素的顺序.sort() 对数组的元素进行排序. 可以不写,也可以传一个自定义函数用来排序. var = [2, 14, 3, 37, 5, 40];console.log( .sort()); // [14, 2, 3, 37, 40, 5]console.log( .reverse()); // [5, 40, 37, 3, 2, 14] var = [5, 21, 19, 8, 3];function sortFn(a ,b ) {return