常用排序算法集合-C实现

之前熟悉C的时候写着玩的,就当做笔记用吧:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define MAX 8

void print_r(int *arr,int len);

static void usage(void)
{
    printf("-s            selection sort\n"
           "-b            show unsorted status\n"
           "-m            merge sort\n"
           "-i            insertion sort\n"
           "-I            Information\n"
           "-h            help and exit\n");
    return;
}

static void usage_info(void)
{
    printf("这是一个排序算法的测试程序\n"
           "目前包括选择排序,插入排序和合并排序\n");
    return;
}

int* create_arr(int *arr)
{
    srand(time(NULL));
    int i;
    for(i=0;i<MAX;i++)
    {
        arr[i]=rand()%100;
    }
    return arr;
}

void insertion_sort(int arr[])
{

    int temp = 0,j = 0,i = 0;

    for(j = 1;j<MAX;j++)
    {
        i = j-1;
        temp = arr[j];

        while(i >= 0 && arr[i] < temp)
        {
            arr[i+1] = arr[i];
            i--;
        }
        arr[i+1] = temp;
    }
}

void selection_sort(int arr[],int len)
{
    int i,j=0,index,key;

    for(i=0;i < len;i++)
    {
        key = arr[i];
        index = i;
        j = i+1;

        while(j < len)
        {
            if(arr[j] < key)
            {
                key = arr[j];
                index = j;
            }
            j++;
        }

        arr[index] = arr[i];
        arr[i] = key;
    }

}
/**
 * start 数组开始下标
 * mid   数组分割下标
 * end   数组结束下标
 */
void merge(int arr[],int start,int mid,int end)
{
    int szie_L,szie_R,i,j,k;
    szie_L = mid+1-start; //左数组大小
    szie_R = end-mid;     //右数组大小
    int arr_L[szie_L],arr_R[szie_R];
    for(i = 0;i < szie_L;i++)
    {
        arr_L[i] = arr[start+i];
    }
    for(j = 0;j < szie_R;j++)
    {
        arr_R[j] = arr[mid+j+1];
    }

    i = 0;
    j = 0;

    for(k = start;k <= end;k++)
    {
        if((i < szie_L) && (j < szie_R))
        {
            if(arr_L[i] <= arr_R[j])
            {
                arr[k] = arr_L[i];
                i++;
            }
            else if(arr_L[i] > arr_R[j])
            {
                arr[k] = arr_R[j];
                j++;
            }
         }
        else if(j >= szie_R)
        {
            arr[k] = arr_L[i];
            i++;
        }
        else
        {
            arr[k] = arr_R[j];
            j++;
        }
    }
}
/**
 * start 数组开始下标
 * end 数组结束下标
 */
void merge_sort(int arr[],int start,int end)
{
    int mid; //用来分割数组的下标
    if(start < end)
    {
        mid = (int)((start+end)/2);
        merge_sort(arr,start,mid);
        merge_sort(arr,mid+1,end);
        merge(arr,start,mid,end);
    }
}

void print_r(int *arr,int len)
{
    int i;
    for(i=0;i<len;i++)
    {
        printf("[%d]=>%d\n",i,arr[i]);
    }
}
void main(int argc ,char **argv)
{
    int i,c,sorted=0;
    int arr[MAX];
    create_arr(arr);
    if(argc>1)
    {
        while(-1 != (c = getopt(argc,argv,"hsimIb")))
        {
            switch(c)
            {
                case ‘b‘:
                          printf("before sorting : \n");
                          print_r(arr,MAX);
                          printf("=========================================\n");
                          break;
                case ‘h‘:
                          usage();
                          break;
                case ‘s‘:
                          selection_sort(arr,MAX);
                          printf("selection sorting : \n");
                          sorted = 1;
                          break;
                case ‘i‘:
                          insertion_sort(arr);
                          printf("insertion sorting : \n");
                          sorted = 1;
                          break;
                case ‘m‘:
                          merge_sort(arr,0,MAX-1);
                          printf("merge sorting : \n");
                          sorted = 1;
                          break;
                case ‘I‘:
                          usage_info();
                          break;
                default : usage();
                          break;
            }
        }

        if(sorted)
        {
            print_r(arr,MAX);
        }
    }
    else
    {
        usage();
        exit(0);
    }
}
时间: 2024-10-17 06:33:39

常用排序算法集合-C实现的相关文章

Java常用排序算法+程序员必须掌握的8大排序算法+二分法查找法

Java 常用排序算法/程序员必须掌握的 8大排序算法 本文由网络资料整理转载而来,如有问题,欢迎指正! 分类: 1)插入排序(直接插入排序.希尔排序) 2)交换排序(冒泡排序.快速排序) 3)选择排序(直接选择排序.堆排序) 4)归并排序 5)分配排序(基数排序) 所需辅助空间最多:归并排序 所需辅助空间最少:堆排序 平均速度最快:快速排序 不稳定:快速排序,希尔排序,堆排序. 先来看看 8种排序之间的关系: 1.直接插入排序 (1)基本思想:在要排序的一组数中,假设前面(n-1)[n>=2]

常用排序算法比较与分析

一.常用排序算法简述 下面主要从排序算法的基本概念.原理出发,分别从算法的时间复杂度.空间复杂度.算法的稳定性和速度等方面进行分析比较.依据待排序的问题大小(记录数量 n)的不同,排序过程中需要的存储器空间也不同,由此将排序算法分为两大类:[内排序].[外排序]. 内排序:指排序时数据元素全部存放在计算机的随机存储器RAM中. 外排序:待排序记录的数量很大,以致内存一次不能容纳全部记录,在排序过程中还需要对外存进行访问的排序过程. 先了解一下常见排序算法的分类关系(见图1-1) 图1-1 常见排

七种常用排序算法

七种常用排序算法 一.常见排序算法一览: 时间复杂度: 是一个函数,它定量描述了该算法的运行时间. 空间复杂度:一个算法在运行过程中临时占用存储空间大小的量度. 稳定性:保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同就稳定,反之不稳定. 视觉直观感受 7 种常用的排序算法 二.算法C#实现: 1. 直接插入排序: using System; using System.Collections.Generic; using System.Linq; using Sys

常用排序算法之——归并排序

归并排序的原理: 如果数组的元素个数大于1,则: 将数组平均分为两部分: 左边的数组归并排序:递归 右边的数组归并排序:递归 将两个各自有序的数组合并,需要一个额外的辅助数组,暂时保存合并结果:返回 否则,数组元素个数为1时,已经有序:直接返回. 稳定排序.时间复杂度在最坏.最好.平均情况下都为O(N lgN),空间复杂度为O(N). 代码: 1 #include <iostream> 2 using namespace std; 3 4 template<typename T>

常用排序算法之——快速排序

快速排序的原理: 首先找一个标兵值,等于某一个元素值:遍历数组,将数组分为小于标兵值和大于标兵值的两部分:然后分别对两个部分采用快速排序,递归. 分开数组时,维持一个指针,指向已找到小部分的最后一个元素:一个指针用于遍历. 不稳定排序算法.当数组已经有序时,时间复杂度最差,为O(N2),平均.最优情况下都为O(N lgN). 代码如下: 1 #include <iostream> 2 using namespace std; 3 4 template<typename T> 5 v

javascript常用排序算法实现

毕业后,由于工作中很少需要自已去写一些排序,所以那些排序算法都忘得差不多了,不过排序是最基础的算法,还是不能落下啦,于是找了一些资料,然后用Javascript实现了一些常用的算法,具体代码如下: <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <title>

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

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

常用排序算法时间复杂度和空间复杂度简析

1. preface /**** *    This article will try to explain something about: *        --Bubble sort. *        --Quick sort. *        --Merge sort. *        --Heap sort. *    To read this, some prerequisites is necessary: *        --a survive skill in C pr

视觉直观感受7种常用排序算法

视觉直观感受若干常用排序算法 1 快速排序 介绍: 快速排序是由东尼·霍尔所发展的一种排序算法.在平均状况下,排序 n 个项目要Ο(n log n)次比较.在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见.事实上,快速排序通常明显比其他Ο(n log n) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来,且在大部分真实世界的数据,可以决定设计的选择,减少所需时间的二次方项之可能性. 步骤: 从数列中挑出一个元素,称为 "基准"(pivo