精华内容
下载资源
问答
  • c语言经典排序算法

    2011-09-13 20:50:42
    c语言经典排序算法 常见经典排序算法 1.希尔排序 2.二分插入法 3.直接插入法 4.带哨兵的直接排序法 5.冒泡排序 6.选择排序 7.快速排序 8.堆排序
  • C语言代码 直接插入法排序算法fun1,冒泡法排序排列算法fun2,直接选择法排序算法fun3。
  • C语言排序算法详解

    2017-02-19 16:02:05
    C语言下排序算法详解 选择排序法 冒泡排序法 交换排序法 插入排序法 折半(二分排序法) yuanli xing 东西就不在这里赘述了,直接上代码先,原理的东西都在代码上面有注释: sort.h#ifndef __SORT_H_ #define __SORT_...

    C语言下排序算法详解

    • 选择排序法
    • 冒泡排序法
    • 交换排序法
    • 插入排序法
    • 折半(二分排序法)

    yuanli xing 东西就不在这里赘述了,直接上代码先,原理的东西都在代码上面有注释:
    sort.h

    #ifndef __SORT_H_
    #define __SORT_H_
    
    //选择排序算法
    extern void selectSort(int *num_pointer,const int num);
    
    //冒泡排序算法
    extern void bubbleSort(int *num_pointer,const int num);
    
    //冒泡排序算法2
    extern void bubbleSort2(int *num_pointer,const int num);
    
    //交换排序算法
    extern void swapSort(int *num_pointer,const int num);
    
    //插入排序法则
    extern void insertSort(int *num_pointer,const int num);
    
    //折半排序法则
    extern void celeritySort(int *num_pointer,const int num);
    #endif

    sort.c

    #include"sort.h"
    #include"swap.h"
    
    /**
    *选择排序法则:9,6,8,7,3
    *算法规则:每一次将数组中的最大的那个数值筛选出来,将这个值提取出来,与最前面没有进行排序的数组元素进行比较
    *那前面没有比较的数值的次数就是整个数组长度-1次,这也是外层循环的次数
    *内层循环也就是从没有比较数组的后面一个数值开始,假设当前没有比较的元素的位置是i的话,那么开始项的位置就是i+1
    *
    *注意:选择排序法只是将最大的数值的位置记录下来,最后再进行一次互换,所以默认有一个记录的下标;用来记录位置,即pos
    *然后用后续的元素与这个最大的数值进行比较
    *
    *选择排序在整个排序过程中进行了N*(N-1)/2次排序,适用于数组数量比较小的数组
    */
    extern void selectSort(int *num_pointer,const int num){
        int pos;
        int i_count = 0;
        int j_count = 0;
    
        int *pointer = num_pointer;
        for( i_count = 0; i_count < num-1; i_count++) {
            pos = i_count;
            for(j_count = i_count + 1;j_count < num; j_count++) {
                if(*(pointer+pos) < *(pointer+j_count)){
                    pos = j_count;
                }
            }
            if(pos != i_count){
                swap(pointer+i_count,pointer+pos);
            }
        }
        printf_array(num_pointer,num);
    }
    
    /**
    *冒泡排序法则:
    *算法规则:冒泡排序法则是在排序的时候,每一次都是去比较相邻的两个数组的数值a[j]与a[j+1]比较,如果需要swap就会立马进行swap,从而将最大的数值筛选出来,然后后一次的比较从前一个最大值的位置下一位元素开始,所以外层的循环为(数组长度-1)次
    *内层循环次数:如果是从数组的0位置开始比较的话,那么循环的内层比较次数为(数组长度-i-1)
    *如果是从最后一个位置开始来进行比较的话,内层的比较条件为(j=数组长度-1,j>=i;j--);
    *
    *注意:不同的方向进行比较的时候,其判别条件也是不一样的 
    *
    *冒泡排序最好的是正序,只要一次,最差的是逆序,需要n×n次,冒泡排序相对是比较稳定的一种排序法,如果数组稍微有序,则效果是比较好的
    */
    extern void bubbleSort(int *num_pointer,const int num){
        int i_count = 0;
        int j_count = 0;
        int *pointer = num_pointer;
        for(i_count = 0;i_count<num;i_count++){
            for(j_count = 0;j_count<num-i_count-1;j_count++){
                if(*(pointer+j_count) < *(pointer+j_count+1)){
                    swap(pointer+j_count,pointer+j_count+1);
                }
            }
        }
        printf_array(num_pointer,num);
    }
    
    extern void bubbleSort2(int *num_pointer,const int num){
        int i_count = 0;
        int j_count = 0;
        int *pointer = num_pointer;
        for(i_count = 1;i_count < num ;i_count++){
            for(j_count = num -1 ;j_count >= i_count;j_count--){
                if(*(pointer+j_count) >  *(pointer+j_count-1)){
                    swap(pointer+j_count,pointer+j_count-1);
                }
            }
        }
        printf_array(num_pointer,num);
    }
    
    
    /**
    *交换排序法则:每一次比较都会进行一次互换,比较的前一个数值从0,到num-1
    *比较的后值从1,num;(从前数值的后一项开始的,即从i_count+1开始);
    *
    *注意:在每一次比较的时候都是会进行交换的
    *
    *与冒泡排序是一样的,正序是最快的,而倒序是最慢的,所以数组稍微有序的时候,效果是比较好的
    */
    extern void swapSort(int *num_pointer,const int num){
        int i_count;
        int j_count;
        int *pointer = num_pointer;
        for(i_count = 0; i_count < num-1;i_count++){
            for(j_count=i_count + 1;j_count < num ;j_count++){
                if(*(pointer+i_count) < *(pointer+j_count)){
                    swap(pointer+i_count,pointer+j_count);
                }
            }
        }
        printf_array(num_pointer,num);
    }
    
    /**
    *插入排序法则
    *
    *插入排序法则相对是比较复杂,其根本工作原理就是抽出一个数据,在前面的数据中寻找相应的位置,然后进行插入,然后继续下一个数据,一直到数据完成排序
    *1:首先取出第一数值
    *2:取出第二个数值,如果第二个数值大于第一个数值,就放在第一个的后面。如果小于就放前面
    *3:取出第三个数值,与最后一个数值进行比较,如果大于就放后面。如果小于,就与前面一个数值进行比较,再判断放在前面还是后面
    *4:以此类推,总是先与最后一个数值进行比较
    *
    *优点:如果数组有序那么会具有较快的运算速度 
    */
    extern void insertSort(int *num_pointer,const int num){
        int i_count = 0;
        int *pointer = num_pointer;
        int temp;
        int pos;
        //从0开始意思是第一次取出一个数值,从1开始就是默认拿出了第一个数值
        for(i_count = 1;i_count<num;i_count++){
    
            temp = *(pointer+i_count);//取出的数值
    
            pos = i_count-1;//最后一个数值的位置
    
            //当当前元素的前面位置>0并且当前位置的数值小于前面的数值的时候(取出的数值小于最后一个数值)
            while((pos>=0) && (temp < *(pointer+pos))){
                swap(pointer+1+pos,pointer+pos);
                pos--;
            }
            *(pointer+pos+1)  = temp;
        }
        printf_array(num_pointer,num);
    }   
    
    
    
    /**
    *折半排序法则
    *折半排序算法通常也叫做快速排序算法,是选择中间的一个数值middle,然后把中间数值小的放在左边,比中间数值大的数据放在右边,然后对两边分别进行递归的方法进行重新调用;
    *1:先取出中间的数值
    *2:左边去与中间middle进行比较,如果左边的数值大于middle,筛选出来
    *3:右边的数值与中间middle进行比较,如果右边的小于middle,筛选出来,将左右两边的这两个数值进行互换,然后再将pos各往下一个元素提一位,再次进行比较
    *这样可以在第一次遍历完了之后,将以中间middle为基准的数值,进行左右分布,
    *4:然后再次将左边的一组进行单独二分排序,将右边的一组进行二分排序
    */
    extern void celeritySort(int * num_pointer,const int left,const int right){
        int *pointer = num_pointer;
        int i_count = left;
        int j_count = right;
        int middle  = *(pointer+(left+right)/2);//拿到最中间的数的数值
    
        do{ 
            while((*(pointer+i_count) < middle) && (i_count<right)){
                i_count++;
            }
            while((*(pointer+j_count) > middle) && (j_count>left)){
                j_count--;
            }
            if(i_count <= j_count){
                swap(pointer+i_count,pointer+j_count);
                i_count++;
                j_count--;
            }
        }while(i_count<=j_count);
    
        //递归左边
        if(left<j_count){
            celeritySort(num_pointer,left,j_count);
        }
    
        //递归右边
        if(i_count<right){
            celeritySort(num_pointer,i_count,right);
        }
    
        printf_array(num_pointer,right+1);
    }

    swap.h

    #ifndef __SWAP_H__
    #define __SWAP_H_
    
    extern void swap(int *,int *);
    
    extern void printf_array(int *,int);
    #endif

    swap.c

    #include"swap.h"
    #include<stdio.h>
    
    extern void swap(int *num_pointer1,int *num_pointer2){
        int temp;
        temp = *num_pointer1;
        *num_pointer1 = *num_pointer2;
        *num_pointer2 = temp;
    }
    
    extern void printf_array(int * pointer,int num){
        int count = 0;
        for(count;count<num;count++){
            printf("position:[%d]:value:%d\n",count,*(pointer+count));
        }
    
    }

    ceshi daima :
    sort_algorithm.c

    #include<stdio.h>
    #include<stdio.h>
    #include"sort.h"
    #include"swap.h"
    
    int main(int argc,char *argv[]){
        int select = 0;
        int array_length;
        int num = 0;
        printf("==============\n");
        printf("1:selectSort\n");
        printf("2:bubbleSort\n");
        printf("3:bubbleSort2\n");
        printf("4:swapSort\n");
        printf("5:insertSort\n");
        printf("6:celeritySort\n");
        printf("==============\n");
    
        scanf("%d",&select);
    
        printf("please input the array length you want!!\n");
        scanf("%d",&array_length);
    
        int array_nums[array_length];
    
        for(num ;num<array_length;num++){
            printf("please input the array element\n");
            scanf("%d",&array_nums[num]);
        }
    
        printf_array(array_nums,array_length);
        printf("---------------------------\n");
        if(select == 1){    
            selectSort(array_nums,array_length);
        }else if(select == 2){
            bubbleSort(array_nums,array_length);
        }else if(select == 4){
            swapSort(array_nums,array_length);
        }else if(select == 3){
            bubbleSort2(array_nums,array_length);
        }else if(select == 5){
            insertSort(array_nums,array_length);
        }else if(select == 6){
            celeritySort(array_nums,0,array_length-1);
        }else{
            printf("select error\n");
        }
        return 0;
    }

    最后谢谢大家的访问:欢迎大家持续访问,有错误的地方希望各位看客能够及时指出,谢谢

    展开全文
  • C语言排序算法之简单交换法排序直接选择排序,冒泡排序,最近考试要用到,网上也有很多例子,我觉得还是自己写的看得懂一些。 简单交换法排序 1 /*简单交换法排序 2 根据序列中两个记录键值的比较结果来...

      C语言排序算法之简单交换法排序,直接选择排序,冒泡排序,最近考试要用到,网上也有很多例子,我觉得还是自己写的看得懂一些。

    1. 简单交换法排序
       1 /*简单交换法排序
       2 根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置
       3 交换排序的特点是:将键值较大的记录向序列的尾部移动,键值较小的记录向序列的前部移动 
       4 不稳定 
       5 */
       6 #include<windows.h>
       7 #include<stdio.h>
       8 void main(){
       9     int i,j,arr[10]={20,36,58,23,10,9,14,99,3,66},t;
      10     int size = sizeof(arr)/sizeof(int);//计算数组的大小 
      11     for(i = 0;i< size-1;i++){//n个数进行n-1轮比较 
      12         for(j = i+1;j< size;j++)//每一轮比较时,后面的数与i为下标的数比较 
      13             if(arr[j]<arr[i]){//如果i为下标的数比后面的一个数大,将两个数交换位置 
      14                 t=arr[j];
      15                 arr[j]=arr[i];
      16                 arr[i]=t;
      17             }
      18     }
      19     
      20     for(i = 0;i< size;i++){//输出 
      21         printf("%d ",arr[i]);
      22     } 
      23     
      24     system("pause");
      25 } 

       

    2. 直接选择排序
       1 /*选择排序
       2 每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。 
       3 选择排序是不稳定的排序方法(比如序列[5, 5, 3]第一次就将第一个[5]与[3]交换,导致第一个5挪动到第二个5后面)
       4 */
       5 #include<windows.h>
       6 #include<stdio.h>
       7 void main(){
       8     int min,i,j,arr[10]={20,36,58,23,10,9,14,99,3,66},t;
       9     int size = sizeof(arr)/sizeof(int);//计算数组的大小 
      10     for(i = 0; i< size-1;i++){//n个数进行n-1轮比较 
      11         min = i;//每一轮假定i为下标的这个数为最小值,记录下标 
      12         for(j = i+1;j < size;j++)//每一轮比较时,后面的数与min为下标的数比较 
      13             if(arr[j]<arr[min]) min = j;//后面的数比min为下标的数小,更换min 
      14         if(min != i){//如果min的值发生了变化即当前下标为i的数不是最小值,交换 
      15             t = arr[i];
      16             arr[i]=arr[min];
      17             arr[min] = t;
      18         }
      19     }
      20     
      21     for(i = 0;i< size;i++){//输出 
      22         printf("%d ",arr[i]);
      23     } 
      24     
      25     system("pause");
      26         
      27 } 

       

    3. 冒泡排序
      /*冒泡排序
      重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。
      走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成
      */
      #include<windows.h>
      #include<stdio.h>
      void main(){
          int min,i,j,arr[10]={20,36,58,23,10,9,14,99,3,66},t,noswap;
          int size = sizeof(arr)/sizeof(int);//计算数组的大小 
          for(i = 0; i< size-1;i++){//n个数进行n-1轮比较 
              noswap = 1;//标记是否发生交换,以避免对已经有序的序列再排序 
              for(j = 0;j<size-1-i;j++){ 
                  if(arr[j]>arr[j+1]){//如果前一个数比后一个数大,交换 
                      t=arr[j];
                      arr[j]=arr[j+1];
                      arr[j+1]=t;
                      noswap = 0;//发生了交换 
                  }
              } 
              
              if(noswap) break; //没有发生交换,说明已经有序,无需再排序,退出循环 
          }
          
          for(i = 0;i< size;i++){//输出 
              printf("%d ",arr[i]);
          } 
          
          system("pause");
              
      }

       

    转载于:https://www.cnblogs.com/hyyq/p/8296045.html

    展开全文
  • 算法是采用分治(Divide and Conquer)的一个非常典型的应用。 算法步骤: 1. 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列 2. 设定两个指针,最初位置分别为两个已经排序序列的...
  • 插入排序法 基本原理 从第二个数开始,对每个数从后往前依次与它之前的数进行比较,以此来找到它应该插入的位置,找到位置之后,对所有元素后移一位,然后将它插入到它应该所在的位置,循环后完成排序。 具体代码...

    插入排序法

    • 基本原理
      从第二个数开始,对每个数从后往前依次与它之前的数进行比较,以此来找到它应该插入的位置,找到位置之后,对所有元素后移一位,然后将它插入到它应该所在的位置,循环后完成排序。

    具体代码如下:

    //直接插入排序(从小到大)
    #include<stdio.h>
    int main()
    {
        int a[10]= {3,8,7,0,9,2,1,6,5,4};
        int i,j,temp;
        for(i=1; i<10; i++)
        {
            temp=a[i];  
            for(j=i-1; j>=0&&temp<a[j]; j--)//从后往前依次比较寻找插入位置 
                a[j+1]=a[j];//所有元素后移一位 
            a[j+1]=temp; //插入元素//为什么是j+1?因为在循环中减了个1,所以这里+1才是真正要插入的位置 
        } 
        for(i=0; i<10; i++)
            printf("%d ",a[i]);
        return 0;
    }
    展开全文
  • 希尔(Shell)排序法(又称宿小增量排序,是1959年由D.L.Shell提出来的) /* Shell 排序法 */ #include void sort(int v[],int n) { int gap,i,j,temp; for(gap=n/2;gap>0;gap /= 2) /* 设置排序的步长,步长gap...
    一.希尔(Shell)排序法(又称宿小增量排序,是1959年由D.L.Shell提出来的)
    
    /* Shell 排序法 */
    #include <stdio.h>
    void sort(int v[],int n)
    {
         int gap,i,j,temp;
         for(gap=n/2;gap>0;gap /= 2) /* 设置排序的步长,步长gap每次减半,直到减到1 */
         {
              for(i=gap;i<n;i++)  /* 定位到每一个元素 */
              {
                   for(j=i-gap;(j >= 0) && (v[j] > v[j+gap]);j -= gap ) /* 比较相距gap远的两个元素的大小,根据排序方向决定如何调换 */
                   {
                    temp=v[j];
                    v[j]=v[j+gap];
                    v[j+gap]=temp;
                   }
              }
         }
    }
    二.二分插入法
    /* 二分插入法 */
    void HalfInsertSort(int a[], int len)
    {
         int i, j,temp;
         int low, high, mid;
         for (i=1; i<len; i++)
         {
              temp = a[i];/* 保存但前元素 */
              low = 0;
              high = i-1;
              while (low <= high) /* 在a[low...high]中折半查找有序插入的位置 */
              {
                   mid = (low + high) / 2; /* 找到中间元素 */
                   if (a[mid] > temp)  /* 如果中间元素比但前元素大,当前元素要插入到中间元素的左侧 */
                   {
                    high = mid-1;
                   }
                   else    /* 如果中间元素比当前元素小,但前元素要插入到中间元素的右侧 */
                   {
                    low = mid+1;
                   }
              }       /* 找到当前元素的位置,在low和high之间 */
              for (j=i-1; j>high; j--)/* 元素后移 */
              {
               a[j+1] = a[j];
              }
              a[high+1] = temp; /* 插入 */
         }
    }
    
    三.直接插入法
    /*直接插入法*/
    void InsertionSort(int input[],int len) 
    {
         int i,j,temp;
         for (i = 1; i < len; i++) 
         {
              temp = input[i];  /* 操作当前元素,先保存在其它变量中 */
              for (j = i - 1;j>-1&&input[j] > temp ; j--) /* 从当前元素的上一个元素开始查找合适的位置 */
              {
                   input[j + 1] = input[j]; /* 一边找一边移动元素 */
                   input[j] = temp;
              }
         }
    }
    四.带哨兵的直接排序法
     /**
         * 带哨兵的直接插入排序,数组的第一个元素不用于存储有效数据
         * 将input[0]作为哨兵,可以避免判定input[j]中,数组是否越界
         * 因为在j--的过程中,当j减小到0时,变成了input[0]与input[0]
         * 自身进行比较,很明显这个时候说明位置i之前的数字都比input[i]小
         * 位置i上的数字不需要移动,直接进入下一轮的插入比较。
         *
         */
    void InsertionSortWithPiquet(int input[],int len) 
    {
         int i,j;
         for (i = 2; i < len; i++)  /* 保证数组input第一元素的存储数据无效,从第二个数据开始与它前面的元素比较 */
         {
              input[0] = input[i];
              for (j = i - 1; input[j] > input[0] ; j--) 
              {
                   input[j + 1] = input[j];
                   input[j] = input[0]; /* input[j]一直都是排序的元素中最大的那一个 */
              }
         }
    }
    五.冒泡法
    
    /* 冒泡排序法 */
    void Bublesort(int a[],int n)
    {
         int i,j,k;
         for(j=0;j<n;j++)   /* 气泡法要排序n次*/
         {
              for(i=0;i<n-j;i++)  /* 值比较大的元素沉下去后,只把剩下的元素中的最大值再沉下去就可以啦 */
              {
                   if(a[i]>a[i+1])  /* 把值比较大的元素沉到底 */
                   {
                        k=a[i];
                        a[i]=a[i+1];
                        a[i+1]=k;
                   }
              }
         }
    }
    
    六.选择排序法
    /*算法原理:首先以一个元素为基准,从一个方向开始扫描,
     * 比如从左至右扫描,以A[0]为基准。接下来从A[0]...A[9]
     * 中找出最小的元素,将其与A[0]交换。然后将基准位置右
     * 移一位,重复上面的动作,比如,以A[1]为基准,找出
     * A[1]~A[9]中最小的,将其与A[1]交换。一直进行到基准位
     * 置移到数组最后一个元素时排序结束(此时基准左边所有元素
     * 均递增有序,而基准为最后一个元素,故完成排序)。
     */
    void Selectsort(int A[],int n) 
    {
         int i,j,min,temp; 
         for(i=0;i<n;i++) 
         {
              min=i; 
              for(j=i+1;j<=n;j++)  /* 从j往前的数据都是排好的,所以从j开始往下找剩下的元素中最小的 */
              {
                   if(A[min]>A[j])  /* 把剩下元素中最小的那个放到A[i]中 */
                   {
                    temp=A[i]; 
                    A[i]=A[j]; 
                    A[j]=temp;
                   }
              }
        } 
    }
    七.快速排序
    
    /* 快速排序(quick sort)。在这种方法中,
     * n 个元素被分成三段(组):左段left,
     * 右段right和中段middle。中段
     * 仅包含一个元素。左段中各元素都小于等
     * 于中段元素,右段中各元素都大于等于中
     * 段元素。因此left和right中的元
     * 素可以独立排序,并且不必对left和
     * right的排序结果进行合并。
     * 使用快速排序方法对a[0:n-1]排序
     * 从a[0:n-1]中选择一个元素作为middle,
     * 该元素为支点把余下的元素分割为两段left
     * 和right,使得left中的元素都小于
     * 等于支点,而right 中的元素都大于等于支点
     * 递归地使用快速排序方法对left 进行排序
     * 递归地使用快速排序方法对right 进行排序
     * 所得结果为left+middle+right
     */
    void Quick_sort(int data[],int low,int high) 
    {
     int mid; 
     if(low<high) 
     {
      mid=Partition(data,low,high); 
      Quick_sort(data,low,mid-1); /* 递归调用 */
      Quick_sort(data,mid+1,high);
     } 
    }
    /* 要注意看清楚下面的数据之间是如何替换的,
     * 首先选一个中间值,就是第一个元素data[low],
     * 然后从该元素的最右侧开始找到比它小的元素,把
     * 该元素复制到它中间值原来的位置(data[low]=data[high]),
     * 然后从该元素的最左侧开始找到比它大的元素,把
     * 该元素复制到上边刚刚找到的那个元素的位置(data[high]=data[low]),
     * 最后将这个刚空出来的位置装入中间值(data[low]=data[0]),
     * 这样一来比mid大的都会跑到mid的右侧,小于mid的会在左侧,
     * 最后一行,返回的low是中间元素的位置,左右分别递归就可以排好序了。
     */
    int Partition(int data[],int low,int high) 
    {
     int mid; 
        data[0]=data[low];
     mid=data[low]; 
     while(low < high) 
     {
      while((low < high) && (data[high] >= mid))
      {
       --high;
      }
      data[low]=data[high]; /* 从high的位置开始往low的方向找,找到比data[low]小的元素,存到data[low]中 */
      
      while((low < high) && (data[low] < mid)) /* 新得到的data[low]肯定小于原来的data[low]即mid */
      {
       ++low;
      }
      data[high]=data[low];  /* 从low的位置开始往high的方向找,找到比data[high]大的元素,存在data[high]中 */
     }
     data[low]=data[0];    /* 把low的新位置存上原来的data[low]的数据 */
     return low;     /* 递归时,把它做为右侧元素的low */
    } 
    
    
    八.堆排序
    
    /**************************************************************
     * 堆的定义 n 个元素的序列 {k1,k2,...,kn}当且仅当满足下列关系时,
     * 称为堆:
     * ki<=k2i     ki<=k2i+1     (i=1,2,...,n/2)
     * 或
     * ki>=k2i     ki>=k2i+1     (i=1,2,...,n/2)
     * 堆排序思路:
     * 建立在树形选择排序基础上;
     * 将待排序列建成堆(初始堆生成)后,序列的第一个元素(堆顶元素)就一定是序列中的最大元素;
     * 将其与序列的最后一个元素交换,将序列长度减一;
     * 再将序列建成堆(堆调整)后,堆顶元素仍是序列中的最大元素,再次将其与序列最后一个元素交换并缩短序列长度;
     * 反复此过程,直至序列长度为一,所得序列即为排序后结果。
     **************************************************************/
    void HeapAdjust(int data[],int s,int m) /* 排列成堆的形式 */
    { 
         int j,rc; 
         rc=data[s];     /* 保存处理元素 */
         for(j=2*s;j<=m;j*=2)        /* 处理父亲元素 */
         {
              if(j<m && data[j]<data[j+1])  ++j; /* 取较大的孩子节点 */
              if(rc>data[j]) break; 
              data[s]=data[j];   /* 父节点比较大的孩子节点大则互换 ,保证父节点比所有子节点都大(父节点存储在前面)*/
              s=j; 
         } 
        data[s]=rc;     /* 相当于data[j]=rc */
    }
    void Heap_sort(int data[],int long_n) /* 堆排序函数 */
    {
         int i,temp; 
         for(i=long_n/2;i>0;--i)  /* 还没有读懂这样处理的原因,希望大家不吝赐教 */
         {
          HeapAdjust(data,i,long_n); /* 处理后,data[i]是这个数组后半部分的最大值 */
         }
         for(i=long_n;i>0;--i)
         {
          temp=data[1];    /* 把根元素(剩下元素中最大的那个)放到结尾 ,下一次只要排剩下的数就可以啦*/
          data[1]=data[i]; 
          data[i]=temp;   
          HeapAdjust(data,1,i-1);
         }
    }
    

    展开全文
  • C语言之插入排序算法

    2016-07-28 16:22:00
    直接插入排序是一种简单的插入排序法,其基本思想是:把待排序的纪录按其关键码值的大小逐个插入到一个已经排好序的有序序列中,直到所有的纪录插入完为止,得到一个新的有序序列。选择排序对大小为N的无序数组R[N]...
  • 希尔(Shell)排序法(又称宿小增量排序,是1959年由D.L.Shell提出来的) /* Shell 排序法 */ #include void sort(int v[],int n) { int gap,i,j,temp; for(gap=n/2;gap>0;gap /= 2) /* 设置排序的步长,步长gap...
  • C语言算法--直接插入排序法

    千次阅读 多人点赞 2018-07-09 23:53:47
    直接插入排序法的思想是:  对于一个数组,检查其中第i个数字,如果在它的左边的数字比它大,进行交换,这个动作一直继续下去,直到这个数字的左边数字比它还要小,就可以停止了。插入排序法主要的回圈有两个变数...
  • 常见经典排序算法 1.希尔排序 2.二分插入法 3.直接插入法 4.带哨兵的直接排序法 5.冒泡排序 6.选择排序 7.快速排序 8.堆排序
  • 直接插入排序法是指将一个记录插入到已排好序的有序序列中,使整个序列在新插入了一个记录之后仍然有序,插入位置的确定是通过将待插入的记录与有序区中的各记录自右向左依次比较其关键字值的大小确定的。...
  • 算法思想简单描述:在直接插入排序算法中,每次插入一个数,使有序序列只增加1个节点,并且对插入下一个数没有提供任何帮助。如果比较相隔较远距离(称为增量)的数,使得数移动时能跨过多个元素,则进行一次比较就...
  • 排序算法设计和比较实验报告《数据结构》实验报告五专业: 自动化 班级: 0710 学号: 0901071002 姓名... 12.15 程序:排序算法设计比较实验 排序算法问题描述:利用直接插入排序、冒泡排序、快速排序二、程序设计...
  • 直接插入排序方法:直接插入排序法 比较着看可以加深印象 原理 按由大到小来说 同直接插入排序一样,也是分有序序列和无序序列,将待排序的无序序列插入到有序序列当中。 二分插入是把待插入数值先和有序序列的中间...
  • 本文将教科书里的冒泡改进下以提高排序效率,并提供标准函数接口,大家可以直接调用!
  • 希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”(Diminishing Increment Sort),是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。 ...
  • 上一篇文章C语言排序方法-----选择排序法中分析了选择排序法,这篇文章分析一下选择排序法的优化算法,二元选择排序法,在选择排序方法中每次找一个最大或者最小的数据放到开始位置,为了提高效率在每次比较的时候...
  • 希尔排序(ShellSort)是插入排序的一种 是针对直接插入排序算法的改进算法先将要排序的一组数按某个增量gap分成若干组,每组中记录的下标相差gap....//希尔排序法 void Shell_Sort(int *a,int len) {
  • C语言——8种经典排序算法

    千次阅读 2011-11-15 17:36:44
    4.带哨兵的直接排序法 5.冒泡排序 6.选择排序 7.快速排序 8.堆排序       一.希尔(Shell)排序法(又称宿小增量排序,是1959年由D.L.Shell提出来的)   /* Shell 排序法 */ #include   void ...
  • 方法概览:   内部排序: 1.插入类排序 ①直接插入排序 ②希尔...2.选择类排序 ①直接选择排序法 ②堆排序法 3.交换类排序 ①冒泡排序法 ②快速排序法 4.归并类排序  5.基数排序   外部...
  • 排序算法之计数排序C语言版 )

    千次阅读 2018-10-07 11:37:38
    计数排序:计数排序又称为鸽巢原理,是对哈希直接定制变形应用,是一种稳定的算法,它的优势在于在对一定范围内的整数排序时,它的复杂度为Ο(n+k)(其中k是整数的范围),快于任何比较排序算法,当然这是一种牺牲...
  • 排序算法-合并排序C语言实现)

    千次阅读 2015-09-21 01:14:47
    都说“算法是程序的灵魂”,而排序是计算机...这个排序算法比起直接的冒泡的优势,在于它的时间复杂度上的优势O(N*logN)。冒泡要N!当N很大时候,时间差异很大。当然归并排序在空间复杂度上是绝对的劣势O(N*lo
  • 直接插入排序算法

    2020-11-01 23:55:15
    C语言实现直接插入排序算法 插入排序的基本操作是 “有序插入”,也就是将元素按照大小的排布逐一插入到一个有序的数组中。对于数组a[n]通常认为a[0]为长度为1的有序数组,然后按照有序插入,将后面的数组元素逐一...
  • 文章目录分治之快速排序前言一、分治算法的思想二、快速排序的详解1.快速排序的思想2.快速排序的步骤三.程序代码总结 前言 提示:这里可以添加本文要记录的大概内容: 例如:随着人工智能的不断发展,机器学习这...
  • 目录: 一:冒泡排序 定义: 实例1: 二:选择排序 ...三:插入排序 ...四:希尔排序 ...五:归并排序 ...实例5:迭代 ...冒泡排序(英语:Bubble Sort)是一种简单的排序算法 它重复地走访过要排序的...
  • 冒泡排序 冒泡排序(Bubble Sort),又被称为气泡排序或泡沫排序。 它是一种较简单的排序算法。它会遍历若干次要排序的数列,每次遍历时...简单版–直接法 #include<stdio.h> #define N 6 void swap(int *a,int *

空空如也

空空如也

1 2 3 4 5 6
收藏数 107
精华内容 42
关键字:

c语言直接排序法算法

c语言 订阅