*p2){temp=*p1;*p1=*p2;*p2=temp;}if(*p1>*p3){temp=*p1;*p1=*p3;*p3=" />

C语言:用指针法_输入三个数_并从小到大排列输出

C语言:用指针法_输入三个数_并从小到大排列输出
C语言:用指针法_输入三个数_并从小到大排列输出

#include

int main(void)

{

int *p1,*p2,*p3;

int i,j,k,temp;

printf("input date,use space between date \n"); scanf("%d %d %d",&i,&j,&k);

p1=&i;p2=&j;p3=&k;

if(*p1>*p2)

{temp=*p1;*p1=*p2;*p2=temp;}

if(*p1>*p3)

{temp=*p1;*p1=*p3;*p3=temp;}

if(*p2>*p3)

{temp=*p2;*p2=*p3;*p3=temp;}

printf("%d %d %d",*p1,*p2,*p3);

return 0;

}

C语言的四种排序

简单选择排序 /*对整型数组的元素进行简单选择排序(源程序的整型简单选择排序)*/ #include #include #define N 6 void taxis(int b[],int k) { int i,j,temp; for(i=0;ib[j]) { temp=b[i]; b[i]=b[j]; b[j]=temp; } } void main() { int a[N]={9,8,5,6,2,0},i; clrscr(); taxis(a,N); for(i=0;i #include #define N 6 void taxis(int *p1,int k) { int temp,*p2,*p3; for(p2=p1;p2*p3) { temp=*p2; *p2=*p3; *p3=temp; } } void main() { int a[N]={9,8,5,6,2,0},*p; clrscr(); taxis(a,N); for(p=a;p

printf("%d",*p); if(p #include #include #define N 5 void taxis(char *p1[],int k) { int i,j; char *temp; for(i=0;istrlen(p1[j])) { temp=p1[i]; p1[i]=p1[j]; p1[j]=temp; } } void main() { char *a[]={"Follow","BASIC","Great","FORTRAN","Computer"}; int i; clrscr(); taxis(a,N); printf("The result of taxis is:\n"); for(i=0;i #include #include #define N 5 void taxis(char *p1[],int k) { int i,j; char *temp; for(i=0;i0) { temp=p1[i]; p1[i]=p1[j]; p1[j]=temp; } }

c语言的三种排序(冒泡,快速,选择)

关于本周学习汇总 1起泡排序: 过程:首先将第一个记录的关键字和第二字的关键字进行比较,若为逆序,则将两个记录交换。然后再比较第二个记录跟第三个记录关键字。以此类推,直到第n-1个记录和第n个记录关键字进行比较为止。这样做出了第一趟排序。其结果是使得最大的数在第n的记录。然后对前n-1的记录进行同样的操作。结果得出次大的大在n-1记录上。最后直到只有第1个和第2个记录进行比较后,完成所有的排序。由此可以看出需要进行k(1<=k void swap(int *,int *); void bubble(int a[];int n); int main(viod) { Int n ,a[8]; Int i; Printf(“enter n(n<=8):”); scanf(“%d”,&n); printf(“enter a[%d]”,n); for(i=0;ia[j+1]) swap2(&a[j],&a[j+1]); } void swap2(int *px,int *py) { Int t; t=*px; px=*py; py=t;

常见经典排序算法(C语言)1希尔排序 二分插入法 直接插入法 带哨兵的直接排序法 冒泡排序 选择排序 快速排

常见经典排序算法(C语言) 1.希尔排序 2.二分插入法 3.直接插入法 4.带哨兵的直接排序法 5.冒泡排序 6.选择排序 7.快速排序 8.堆排序 一.希尔(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每次减半,直到减到1 */ { for(i=gap;i= 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 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; /* 插入*/ } }

C语言 选择排序

(一)基本思想 每一趟从待排序的数据元素中选出最小(或最大)的一个元素,顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。 n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果: ①初始状态:无序区为R[1..n],有序区为空。 ②第1趟排序 在无序区R[1..n]中选出关键字最小的记录R[k],将它与无序区的第1个记录R[1]交换,使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。 …… ③第i趟排序 第i趟排序开始时,当前有序区和无序区分别为R[1..i-1]和R(1≤i≤n-1)。该趟排序从当前无序区中选出关键字最小的记录R[k],将它与无序区的第1个记录R交换,使R[1..i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。 这样,n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。 [编辑本段]排序过程 【示例】: 初始关键字[49 38 65 97 76 13 27 49] 第一趟排序后13 [38 65 97 76 49 27 49] 第二趟排序后13 27 [65 97 76 49 38 49] 第三趟排序后13 27 38 [97 76 49 65 49] 第四趟排序后13 27 38 49 [49 97 65 76] 第五趟排序后13 27 38 49 49 [97 65 76] 第六趟排序后13 27 38 49 49 65 [97 76] 第七趟排序后13 27 38 49 49 76 [97 76] 最后排序结果13 27 38 49 49 76 76 97 (二)C语言过程 void selectionSort(Type* arr,long len) { long i=0,j=0;/*iterator value*/ long maxPos; assertF(arr!=NULL,"In InsertSort sort,arr is NULL\n"); for(i=len-1;i>=1;i--) { maxPos=i; for(j=0;j

c语言程序设计(排序算法)

《高级语言程序设计》 课程设计报告 题目: 排序算法 专业: 班级: 姓名: 指导教师: 成绩: 计算机与信息工程系 2015年3月26日 2014-2015学年 第2学期

目录 引言 (1) 需求分析 (1) 第一章程序内容及要求 (1) 1.1 冒泡排序 (1) 1.2 选择排序 (2) 1.3 插入排序 (3) 第二章概要设计 (4) 2.1冒泡排序 (4) 2.2选择排序 (5) 2.3插入排序 (6) 第三章程序的比较及其应用 (7) 3.1时间复杂度 (7) 3.2空间复杂度 (7) 3.3稳定程度 (7) 3.4应用及其改进 (8) 第四章程序设计结果 (8) 附录 (9) 参考文献 (12)

引言 伴随着社会的发展,数据也变得越来越庞大。如何将庞大的数据进行很好的排序,使用户更加方便的查找资料,成了一件越来越重要的问题。对于程序员来说,这将是一个挑战。 经常查找资料的朋友都会知道,面对海量的资料,如果其查找资料没有进行排序,那么其查找资料将会是一家非常痛苦的事情。针对这一问题,我们自此通过一个课程设计来解决它。 理论上排序算法有很多种,不过本课程设计只涉及到三种算法。这三种算法包括:冒泡排序,选择排序,直接插入排序。 本课程设计通过对这三种算法的运行情况进行对比,选择最优秀的算法出来。希望通过我的努力能解决一些问题,带来一些方便。 需求分析 本课程题目是排序算法的实现,由于各方面的原因,本科程设计一共需要设计三种排序算法。这三种算法包括:冒泡排序,选择排序,直接插入排序。三种排序算法各有独到之处,因此我们要通过各种调试分析来比较其优劣长短。 由于使用的调试软件及操作系统不一样。因此个别程序在不同的软件上可能会报错。 本课程软件运行的的操作系统为Windows7 64位操作系统。所使用的软件为Microsoft Visual C++6.0以及Turbo C2.0 第一章程序内容及要求 1.1 冒泡排序 冒泡排序(Bubble Sort,台湾译为:泡沫排序或气泡排序)是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端,故名。

c语言各种排序法详细讲解

一插入排序 1.1 直接插入排序 基本思想:每次将一个待排序额记录按其关键码的大小插入到一个已经排好序的有序序列中,直到全部记录排好序。 图解:

1.//直接顺序排序 2.void InsertSort(int r[], int n) 3.{ 4.for (int i=2; i

代码实现: [cpp]view plain copy 1.//希尔排序 2.void ShellSort(int r[], int n) 3.{ 4.int i; 5.int d; 6.int j; 7.for (d=n/2; d>=1; d=d/2) //以增量为d进行直接插入排序 8. { 9.for (i=d+1; i0 && r[0]

C语言综合实现所有排序方法及效率比较

#include #include #include #include #define N 50000 typedef char elemtype; typedef struct { int key; elemtype otheritem; }recdtype,*Recdtype; recdtype R[N]; //直接插入排序 void InsertSort(Recdtype R,int n) { int i,j; for(i=2;i<=n;i++) { R[0]=R[i]; j=i-1; while(R[0].key=high+1;j--) R[j+1]=R[j]; R[high+1]=R[0];

} }/*BinSort*/ //希尔排序 void ShellSort(recdtype R[],int n) { int i,j; for(int d=N/2;d>=1;d=d/2) { for(i=1+d;i<=n;i++) { R[0]=R[i]; j=i-d; while(j>0&&R[0].key=i;j--) { if(R[j+1].key

C语言之选择排序

选择法排序是相对好理解的排序算法。假设要对含有n个数的序列进行升序排列,算法步骤是: 1、从数组存放的n个数中找出最小数的下标(算法见下面的“求最值”),然后将最小数与第1个数交换位置; 2、除第1个数以外,再从其余n-1个数中找出最小数(即n个数中的次小数)的下标,将此数与第2个数交换位置; 3、重复步骤1 n-1趟,即可完成所求。 好了,接下来看代码:

1.#include 2.#include 3.#define n 10 4.int main() 5.{ 6.int a[n],i,j,k,t; 7. printf("随机产生10个100以内的数:\n"); 8.for(i=0;i

排序算法C语言版:直接插入排序

直接插入排序 算法思想简单描述: 在要排序的一组数中,假设前面(n-1) [n>=2] 个数已经是排 好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数也是排好顺序的。如此反复循环,直到全部排好顺序。 直接插入排序是稳定的。算法时间复杂度O(n^2) 算法实现: /* 功能:直接插入排序 输入:数组名称(也就是数组首地址)、数组中元素个数 */ void insert_sort(int *x, int n) { int i, j, t; for (i=1; i

*/ t=*(x+ I ); for (j=i-1; j>=0 && t<*(x+j); j--) /*注意:j=i-1,j--,这里就是下标为i的数,在它前面有序列中找插入位置。*/ { *(x+j+1) = *(x+ j ); /*如果满足条件就往后挪。最坏的情况就是t比下标为0的数都小,它要放在最前面,j==-1,退出循环*/ } *(x+j+1) = t; /*找到下标为i的数的放置位置*/ } }

#include "stdio.h" #include "conio.h" main() { int a[11]={1,4,6,9,13,16,19,28,40,100}; int temp1,temp2,number,end,i,j; printf("original array is:\n"); for(i=0;i<10;i++) printf("%5d",a[i]); printf("\n"); printf("insert a new number:"); scanf("%d",&number); end=a[9]; if(number>end) a[10]=number; else { for(i=0;i<10;i++) { if(a[i]>number) { temp1=a[i]; a[i]=number; for(j=i+1;j<11;j++) { temp2=a[j]; a[j]=temp1; temp1=temp2; } break; } } } for(i=0;i<11;i++) printf("%6d",a[i]); getch();

C语言三种基本排序(简单排序,选择排序,插入排序)演示程序(含注释、每一个步骤,原创) -修订

/******************************************************* 三种基本排序演示程序 说明:此程序适用于理解三种基本排序原理(简单排序,选择排序,插入排序)以及排序的每一个步骤。并且在重要部分有注释. 本人是一家计算机培训机构的兼职教师(培训计算机C二级的),看到许多同学对于排序非常头疼,当然这是二级C的必考点之一,也是贯穿C语言各种知识点的拿分大项。 本程序是自己按照原理写的原创代码,所以定为1分吧(辛苦费吧,一般我搜集的都是免费的(*^__^*) ……,望大家支持下) 此程序我调试运行成功的,如果你复制到编译器不成功,可能是编译器区别造成的。 如果能自己写出这三种排序的同学,我觉得其对C语言基础知识学习就比较牢固了。 时间:2012年12月3日 ********************************************************/ #include #include void main() { int a[5]={5,4,3,2,1}; int i,j,temp,k,s; for(s=0;s<5;s++) { printf("%3d",a[s]); } printf("简单排序\n"); for(i=0;i<5-1;i++)//基准位到倒数第二个就行了,因为最后一个数没有比较 { printf("%d\n",i);/////////////////////////////// for(j=i+1;j<5;j++) { if(a[j]

数据结构(C语言版)实验报告-(内部排序算法比较)

数据结构与算法》实验报告 一、需求分析 问题描述:在教科书中,各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶,或大概执行时间。试通过随机数据比较各算法的关键字比较次数和关键字移动次数,以取得直观感受。 基本要求: (l )对以下 6 种常用的内部排序算法进行比较:起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。 (2 )待排序表的表长不小于100000 ;其中的数据要用伪随机数程序产生;至少要用 5 组不同的输入数据作比较;比较的指标为有关键字参加的比较次数和关键字的移动次数(关键字交换计为 3 次移动)。 ( 3 )最后要对结果作简单分析,包括对各组数据得出结果波动大小的解释。数据测试:二.概要设计 1. 程序所需的抽象数据类型的定义: typedef int BOOL; typedef struct StudentData { } Data; typedef struct LinkList { Data Record[MAXSIZE]; int num; // 存放关键字 int Length; // 数组长度// 用数组存放所有的随机数 // 说明BOOL 是int 的别名 } LinkList int RandArray[MAXSIZE]; // 定义长度为MAXSIZE 的随机数组 void RandomNum() // 随机生成函数

void InitLinkList(LinkList* L) // 初始化链表 // 比较所有排序 2 . 各程序模块之间的层次(调用)关系: BOOL LT(int i, int j,int* CmpNum) // 比较 i 和 j 的大小 void Display(LinkList* L) // 显示输出函数 void ShellSort(LinkList* L, int dlta[], int t,int* CmpNum, int* ChgNum) void QuickSort (LinkList* L, // 快速排序 void HeapSort (LinkList* L, // 堆排序 void BubbleSort(LinkList* L, // 冒泡排序 void SelSort(LinkList* L, // 选择排序 int* CmpNum, int* ChgNum) int* CmpNum, int* ChgNum) int* CmpNum, int* ChgNum) * CmpNum, int* ChgNum) void Compare(LinkList* L,int* CmpNum, int* ChgNum) // 希尔排序

C语言冒泡、插入法、选择排序算法分析

C语言中三种常见排序算法分析 一、冒泡法(起泡法) 算法要求:用起泡法对10个整数按升序排序。 算法分析:如果有n个数,则要进行n-1趟比较。在第1趟比较中要进行n-1次相邻元素的两两比较,在第j趟比较中要进行n-j次两两比较。比较的顺序从前往后,经过一趟比较后,将最值沉底(换到最后一个元素位置),最大值沉底为升序,最小值沉底为降序。 算法源代码: # include main() { int a[10],i,j,t; printf("Please input 10 numbers: "); /*输入源数据*/ for(i=0;i<10;i++) scanf("%d",&a[i]); /*排序*/ for(j=0;j<9;j++) /*外循环控制排序趟数,n个数排n-1趟*/ for(i=0;i<9-j;i++) /*内循环每趟比较的次数,第j趟比较n-j次*/ if(a[i]>a[i+1]) /*相邻元素比较,逆序则交换*/ { t=a[i]; a[i]=a[i+1]; a[i+1]=t; } /*输出排序结果*/ printf("The sorted numbers: "); for(i=0;i<10;i++) printf("%d ",a[i]); printf("\n"); } 算法特点:相邻元素两两比较,每趟将最值沉底即可确定一个数在结果的位置,确定元素位置的顺序是从后往前,其余元素可能作相对位置的调整。可以进行升序或降序排序。 算法分析:定义n-1次循环,每个数字比较n-j次,比较前一个数和后一个数的大小。然后交换顺序。二、选择法 算法要求:用选择法对10个整数按降序排序。 算法分析:每趟选出一个最值和无序序列的第一个数交换,n个数共选n-1趟。第i趟假设i为最值下标,然后将最值和i+1至最后一个数比较,找出最值的下标,若最值下标不为初设值,则将最值元素和下标为i的元素交换。 算法源代码: # include main() { int a[10],i,j,k,t,n=10; printf("Please input 10 numbers:"); for(i=0;i<10;i++) scanf("%d",&a[i]);

c语言实现简单排序(8种方法)

#include #include //冒泡排序 voidbubleSort(int data[], int n); //快速排序 voidquickSort(int data[], int low, int high); intfindPos(int data[], int low, int high); //插入排序 voidbInsertSort(int data[], int n); //希尔排序 voidshellSort(int data[], int n); //选择排序 voidselectSort(int data[], int n); //堆排序 voidheapSort(int data[], int n); void swap(int data[], inti, int j); voidheapAdjust(int data[], inti, int n); //归并排序 voidmergeSort(int data[], int first, int last); void merge(int data[], int low, int mid, int high); //基数排序 voidradixSort(int data[], int n); intgetNumPos(intnum, intpos); int main() { int data[10] = {43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti; printf("原先数组:"); for(i=0;i<10;i++) { printf("%d ", data[i]); } printf("\n"); /*printf("冒泡排序:"); bubleSort(data, 10); for(i=0;i<10;i++) { printf("%d ", data[i]); } printf("\n"); printf("快速排序:"); quickSort(data, 0, 9); for(i=0;i<10;i++) { printf("%d ", data[i]); } printf("\n");

C语言常用排序算法

/* ===================================================================== ======== 相关知识介绍(所有定义只为帮助读者理解相关概念,并非严格定义): 1、稳定排序和非稳定排序 简单地说就是所有相等的数经过某种排序方法后,仍能保持它们在排序之前的相对次序,我们就 说这种排序方法是稳定的。反之,就是非稳定的。 比如:一组数排序前是a1,a2,a3,a4,a5,其中a2=a4,经过某种排序后为 a1,a2,a4,a3,a5, 则我们说这种排序是稳定的,因为a2排序前在a4的前面,排序后它还是在a4的前面。假如变成a1,a4, a2,a3,a5就不是稳定的了。 2、内排序和外排序 在排序过程中,所有需要排序的数都在内存,并在内存中调整它们的存储顺序,称为内排序; 在排序过程中,只有部分数被调入内存,并借助内存调整数在外存中的存放顺序排序方法称为外排序。 3、算法的时间复杂度和空间复杂度 所谓算法的时间复杂度,是指执行算法所需要的计算工作量。 一个算法的空间复杂度,一般是指执行这个算法所需要的内存空间。 ===================================================================== =========== */ /* ================================================ 功能:选择排序 输入:数组名称(也就是数组首地址)、数组中元素个数 ================================================ */ /* ==================================================== 算法思想简单描述:

C语言常用排序算法

1、稳定排序和非稳定排序 简单地说就是所有相等的数经过某种排序方法后,仍能保持它们在排序之前的相对次序,我们就说这种排序方法是稳定的。反之,就是非稳定的。 比如:一组数排序前是a1,a2,a3,a4,a5,其中a2=a4,经过某种排序后为a1,a2,a4,a3,a5,则我们说这种排序是稳定的,因为a2排序前在a4的前面,排序后它还是在a4的前面。假如变成a1,a4,a2,a3,a5就不是稳定的了。 2、内排序和外排序在排序过程中,所有需要排序的数都在内存,并在内存中调整它们的存储顺序,称为内排序; 在排序过程中,只有部分数被调入内存,并借助内存调整数在外存中的存放顺序排序方法称为外排序。 3、算法的时间复杂度和空间复杂度 所谓算法的时间复杂度,是指执行算法所需要的计算工作量。 一个算法的空间复杂度,一般是指执行这个算法所需要的内存空间。 ================================================ 功能:选择排序 输入:数组名称(也就是数组首地址)、数组中元素个数 ==================================================== 算法思想简单描述: 在要排序的一组数中,选出最小的一个数与第一个位置的数交换; 然后在剩下的数当中再找最小的与第二个位置的数交换,如此循环 到倒数第二个数和最后一个数比较为止。 选择排序是不稳定的。算法复杂度O(n2)--[n的平方] ===================================================== void select_sort(int*x,int n) { int i,j,min,t; for(i=0;i

简单选择排序(C语言)

选择排序是排序算法的一种,这里以从小到大排序为例进行讲解。 基本思想及举例说明 简单选择排序(从小到大)的基本思想是,首先,选出最小的数,放在第一个位置;然后,选出第二小的数,放在第二个位置;以此类推,直到所有的数从小到大排序。 在实现上,我们通常是先确定第i小的数所在的位置,然后,将其与第i个数进行交换。下面,以对3 2 4 1 进行选择排序说明排序过程,使用min_index 记录当前最小的数所在的位置。 第1轮排序过程(寻找第1小的数所在的位置) 3 2 4 1(最初,min_index=1) 3 2 4 1(3 > 2,所以min_index=2) 3 2 4 1(2 < 4,所以min_index=2) 3 2 4 1(2 > 1,所以min_index=4,这时候确定了第1小的数在位置4) 1 2 4 3 (第1轮结果,将3和1交换,也就是位置1和位置4交换) 第2轮排序过程(寻找第2小的数所在的位置) 1 2 4 3(第1轮结果,min_index=2,只需要从位置2开始寻找) 1 2 4 3(4 > 2,所以min_index=2) 1 2 4 3(3 > 2,所以min_index=2) 1 2 4 3(第2轮结果,因为min_index位置刚好在第2个位置,无需交换) 第3轮排序过程(寻找第3小的数所在的位置) 1 2 4 3(第2轮结果,min_index=3,只需要从位置2开始寻找) 1 2 4 3(4 > 3,所以min_index=4) 1 2 3 4(第3轮结果,将3和4交换,也就是位置4和位置3交换) 至此,排序完毕。 总结及实现 选择排序对大小为N的无序数组R[N]进行排序,进行N-1轮选择过程。第i轮选取第i小的数,并将其放在第i个位置上。当第N-1次完成时,第N小(也就是最大)的数自然在最后的位置上。 下面给出选择排序的C语言实现。 1.#include 2.#include 3.#include https://www.360docs.net/doc/9517069579.html,ing namespace std; 5.

十大经典排序算法-C语言

十大经典排序算法(动图演示,收藏好文) 0、算法概述 0.1 算法分类 十种常见排序算法可以分为两大类: 非线性时间比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此称为非线性时间比较类排序。 线性时间非比较类排序:不通过比较来决定元素间的相对次序,它可以突破基于比较排序的时间下界,以线性时间运行,因此称为线性时间非比较类排序。 0.2 算法复杂度 0.3 相关概念 稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面。 不稳定:如果a原本在b的前面,而a=b,排序之后 a 可能会出现在 b 的后面。时间复杂度:对排序数据的总的操作次数。反映当n变化时,操作次数呈现什么规律。

空间复杂度:是指算法在计算机内执行时所需存储空间的度量,它也是数据规模n 的函数。 1、冒泡排序(Bubble Sort) 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 1.1 算法描述 ?比较相邻的元素。如果第一个比第二个大,就交换它们两个; ?对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素应该会是最大的数; ?针对所有的元素重复以上的步骤,除了最后一个; ?重复步骤1~3,直到排序完成。 1.2 动图演示

1.3 代码实现 function bubbleSort(arr) { var len = arr.length; for (var i = 0; i < len - 1; i++) { for (var j = 0; j < len - 1 - i; j++) { if (arr[j] > arr[j+1]) { // 相邻元素两两对比var temp = arr[j+1]; // 元素交换 arr[j+1] = arr[j]; arr[j] = temp; } } } return arr; }

c语言经典排序算法(8种-含源代码)

天行健,君子以自强不息 常见经典排序算法 1.希尔排序 2.二分插入法 3.直接插入法 4.带哨兵的直接排序法 5.冒泡排序 6.选择排序 7.快速排序 8.堆排序 一.希尔(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每次减半,直到减到1 */ { for(i=gap;i= 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 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]; /* 操作当前元素,先保存在其它变量中 */

C语言四种排序算法时间复杂度比较

1、方案设计: 我这次实验通过随机生成30000个随机数,把随机数存到数组中,用这同一组随机数据分别进行四种排序,直接插入排序、直接选择排序、冒泡排序和快速排序。还通过了调用txt文件把运算所需时间导出,分别输出各个算法所需用时并对用时时长再进行冒泡排序算出用时最短的算法。 2、程序代码: #include #include #include #include #include #define N 30000 void Wrong() //输入错误 { printf("\n语法错误,请重新输入!\n"); getchar(); } void Disp(int a[]) //清屏 { int i; system("cls"); for(i=0; i0&&a[j-1]>temp; j--) a[j]=a[j-1];

a[j]=temp; } } void SelectSort(int a[],int p) //选择排序算法 { int i,j,k; for(i=0; ii; j--) //比较,找出本趟最小关键字的记录if (a[j]

相关文档
最新文档