C语言中的几种常见排序算法

1、冒泡排序法:如果有N个数,两两相邻进行比较,将最值沉入最后一位置,要进行N-1轮比较,

第一轮要比较N-1次,第2轮只要比较N-1-1次,因为第一次已经把最值沉入最后一位置,故

不需在进行比较一次,也就是说每一轮都减少一次,所以第2个for循环中j < n-1;下列代码是升序排序

 1 void bubble_sort(int *num, int n)
 2 {
 3     int num_temp;
 4     for (int i=0; i<n; i++)
 5         for (int j=0; j<n-i;j++)
 6         {
 7             if (num[j] > num[j+1])
 8             {
 9                 num_temp = num[j];
10                 num[j] = num[j+1];
11                 num[j+1] = num_temp;
12             }
13         }
14 }

2、选择排序:每一轮循环中(也就是第2个for循环)只找到最小值的位置,但并不对数据进行交换,

待一轮结束后,判断最小标志是否与当初假设的一样,若不一样,说明其他位置上更小(或大),

在对数据进行交换位置,每轮循环只交换一次数据。而冒泡排序中,第2个循环中,只要找到差

异值就会交换,一轮循环中要进行多次交换。因此冒泡排序比选择排序更耗时。下面代码是降序排序

 1 void select_sort(int *num, int n)
 2 {
 3     int k_min;
 4     int num_temp = 0;
 5
 6     for (int i=0; i<n-1; i++)
 7     {
 8         k_min = i;  //假设第一个最小
 9         for (int j=i+1; j<n; j++)
10         {
11             if (num[k_min] < num[j])
12             {
13                 k_min = j;
14             }
15         }
16
17         if (k_min != i)  //数据交换
18         {
19             num_temp = num[i];
20             num[i] = num[k_min];
21             num[k_min] = num_temp;
22         }
23     }
24 }

整体代码:

 1 #include <iostream.h>
 2 #define N 10
 3
 4 void bubble_sort(int *num, int n)
 5 {
 6     int num_temp;
 7     for (int i=0; i<n; i++)
 8         for (int j=0; j<n-i;j++)
 9         {
10             if (num[j] > num[j+1])
11             {
12                 num_temp = num[j];
13                 num[j] = num[j+1];
14                 num[j+1] = num_temp;
15             }
16         }
17 }
18
19 void select_sort(int *num, int n)
20 {
21     int k_min;
22     int num_temp = 0;
23
24     for (int i=0; i<n-1; i++)
25     {
26         k_min = i;  //假设第一个最小
27         for (int j=i+1; j<n; j++)
28         {
29             if (num[k_min] < num[j])
30             {
31                 k_min = j;
32             }
33         }
34
35         if (k_min != i)  //数据交换
36         {
37             num_temp = num[i];
38             num[i] = num[k_min];
39             num[k_min] = num_temp;
40         }
41     }
42 }
43
44 int main()
45 {
46     int num[N] = {80,6,12,9,15,8,17,50,1,3};
47
48 //    bubble_sort(num,N);
49     select_sort(num,N);
50
51     for (int i=0; i<N; i++)
52     {
53         cout<<num[i]<<endl;
54     }
55
56     return 0;
57 }

 

时间: 2024-10-24 12:42:32

C语言中的几种常见排序算法的相关文章

几种常见排序算法

几种常见排序算法 几种常见排序算法 写在前面 基础介绍 初级排序算法 selection sort选择排序 insertion sort插入排序 ShellSort希尔排序 shuffing不是排序算法 merge sort归并排序 Abstract in-place merge原地归并的抽象方法 Top-down mergesort自顶向下的归并排序 Bottom-up mergesort自底向上的归并排序 quicksort 三向切分的快速排序 Heapsort堆排序 总结和比较 命题 本文

JavaScript版几种常见排序算法

今天发现一篇文章讲“JavaScript版几种常见排序算法”,看着不错,推荐一下原文:http://www.w3cfuns.com/blog-5456021-5404137.html 算法描述: * 冒泡排序:最简单,也最慢,貌似长度小于7最优* 插入排序: 比冒泡快,比快速排序和希尔排序慢,较小数据有优势* 快速排序:这是一个非常快的排序方式,V8的sort方法就使用快速排序和插入排序的结合* 希尔排序:在非chrome下数组长度小于1000,希尔排序比快速更快* 系统方法:在forfox下系

几种常见排序算法的基本介绍,性能分析,和c语言实现

本文介绍7种常见的排序算法,以及他们的原理,性能分析和c语言实现: 为了能够条理清楚,本文所有的算法和解释全部按照升序排序进行 首先准备一个元素无序的数组arr[],数组的长度为length,一个交换函数swap, 在main函数中实现排序函数的调用,并输出排序结果: void swap(int*x , int*y) { int temp = *x; *x = *y; *y = temp; } int main() { int arr[] = { 1,8,5,7,4,6,2,3}; int le

Java中几种常见排序算法

日常操作中常见的排序方法有:冒泡排序.快速排序.选择排序.插入排序.希尔排序等. 冒泡排序是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端. * 冒泡法排序 * 比较相邻的元素.如果第一个比第二个大,就交换他们两个. * 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.在这一点,最后的元素应

几种常见排序算法的总结

下面总结几种常见的排序算法,包括插入排序.选择排序.快速排序.归并排序和堆排序. 时间复杂度: 插入排序 选择排序 快速排序 归并排序 堆排序 Ο(n2) Ο(n2) Ο(nlog(n)) Ο(nlog(n)) Ο(nlog(n)) 算法概述: 插入排序:每次从未排好序的数据堆中拿出一个数,插入到已排好序的数据队列的正确位置. 选择排序:每次从未排好序的数据堆中找到最小的数,插入到已排好序的数据队列的头部. 快速排序:以数据堆中的一个数为标准,将数据堆分为小于等于和大于该数的两堆,对于分割后的两

Java实现9种常见排序算法

常见的排序算法有冒泡排序.选择排序.插入排序.堆排序.归并排序.快速排序.希尔排序.基数排序.计数排序,下面通过Java实现这些排序 1.冒泡排序 package com.buaa; import java.util.Arrays; /** * @ProjectName SortingAlgorithm * @PackageName com.buaa * @ClassName BubbleSort * @Description 冒泡排序 * @Author 刘吉超 * @Date 2016-05

php几种常见排序算法

<?php //从时间上来看,快速排序和归并排序在时间上比较有优势,//但是也比不上sort排序,归并排序比较占用内存! $arr = [4,6,1,2,3,89,56,34,56,23,65];/** * 冒泡排序 * 它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来. * 走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成 */function BubbleSortq($arr) { $len = count($arr); //设置一个空

5种常见排序算法原理&amp;C语言实现

一.冒泡排序(以下各法均以从小到大排序为例,定义len为数组array的长度) 原理:比较相邻元素的大小,对于每次循环,按排序的规则把最值移向数组的一端,同时循环次数依次减少. C代码实现 写法一: //从数组头部开始,某一个元素与其后面的每个元素作比较for(i=0;i<len-1;i++) for(j=i+1;j<len;j++) { if(array[i]>array[j]) { t=array[i];array[i]=array[j];array[j]=t; } } 写法二: /

几种常见排序算法的C++描述

1.首先当然是插入排序啦,算法的时间复杂度其实是O(N^2)的 先来个一般的描述: 1 template<typename Comparable> 2 void insertSort(vector<Comparable> & a) 3 { 4 int j; 5 for (int p = 1; p < a.size(); p++) 6 { 7 Comparable tmp = a[p]; 8 for (int j = p - 1; j > 0 &&