几个简单有趣的c语言代码(简单有趣的c语言程序代码)

大家好，小编今天为大家分享关于简单有趣的c语言程序代码（几个简单有趣的c语言代码）的信息，很多人还不知道，今天让我们一起来看看吧！

1、前言如果说各种编程语言是程序员的招式，那么数据结构和算法就相当于程序员的内功。想写出精炼、优秀的代码，不通过不断的锤炼，是很难做到的。八大排序算法排序算法作为数据结构的重要部分，系统地学习一下是很有必要的。

2、1、排序的概念排序是计算机内经常进行的一种操作，其目的是将一组无序的记录序列调整为有序的记录序列。排序分为内部排序和外部排序。若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。

3、反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。排序分类八大排序算法均属于内部排序。如果按照策略来分类，大致可分为：交换排序、插入排序、选择排序、归并排序和基数排序。

4、如下图所示：

5、算法分析插入排序*直接插入排序*希尔排序选择排序*简单选择排序*堆排序交换排序*冒泡排序*快速排序归并排序基数排序不稳定排序：简单选择排序，快速排序，希尔排序，堆排序稳定排序：冒泡排序，直接插入排序，归并排序，奇数排序1、插入排序将之一个和第二个元素排好序，然后将第3个元素插入到已经排好序的元素中，依次类推（插入排序更好的情况就是数组已经有序了）希尔排序因为插入排序每次只能操作一个元素，效率低。元素个数N，取奇数k=N/2，将下标差值为k的数分为一组（一组元素个数看总元素个数决定），在组内构成有序序列，再取k=k/2，将下标差值为k的数分为一组，构成有序序列，直到k=1，然后再进行直接插入排序。简单选择排序选出最小的数和之一个数交换，再在剩余的数中又选择最小的和第二个数交换，依次类推堆排序以升序排序为例，利用小根堆的性质（堆顶元素最小）不断输出最小元素，直到堆中没有元素构建小根堆输出堆顶元素将堆低元素放一个到堆顶，再重新构造成小根堆，再输出堆顶元素，以此类推冒泡排序改进如果某次冒泡不存在数据交换，则说明已经排序好了，可以直接退出排序改进2：头尾进行冒泡，每次把更大的沉底，最小的浮上去，两边往中间靠快速排序选择一个基准元素，比基准元素小的放基准元素的前面，比基准元素大的放基准元素的后面，这种动作叫分区，每次分区都把一个数列分成了两部分，每次分区都使得一个数字有序，然后将基准元素前面部分和后面部分继续分区，一直分区直到分区的区间中只有一个元素的时候，一个元素的序列肯定是有序的嘛，所以最后一个升序的序列就完成啦。

6、归并排序将一个无序的数列一直一分为二，直到分到序列中只有一个数的时候，这个序列肯定是有序的，因为只有一个数，然后将两个只含有一个数字的序列合并为含有两个数字的有序序列，这样一直进行下去，最后就变成了一个大的有序数列基数排序找到更大的数，开个比更大的数大一点的数组，遍历每个元素，某个元素为k，则a[k]++,更好遍历数组a，a[k]等于多少就输出多少个k。只能处理整型数

7、具体排序讲解下面针对不同排序进行一一讲解。直接插入排序（InsertionSort)算法思想：直接插入排序的核心思想就是：将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过因此，从上面的描述中我们可以发现，直接插入排序可以用两个循环完成：之一层循环：遍历待比较的所有数组元素第二层循环：将本轮选择的元素(selected)与已经排好序的元素(ordered)相比较。

8、如果：selected>ordered，那么将二者交换。

9、算法代码：

10、voidprint(inta[],intn,inti){cout

16、voidprint(inta[],intn,inti){cout

17、void ShellInsertSort(int a[], int n, int dk){for(int i= dk; i

23、voidprint(inta[],intn,inti){couta[j])k=j;}returnk;}

24、/***选择排序**/voidselectSort(inta[],intn){intkey,tmp;for(inti=0;i

25、特别重要的一点性质：任意的叶子节点小于（或大于）它所有的父节点。对此，又分为大顶堆和小顶堆：大顶堆要求节点的元素都要大于其孩子。小顶堆要求节点元素都小于其左右孩子。

26、两者对左右孩子的大小关系不做任何要求。利用堆排序，就是基于大顶堆或者小顶堆的一种排序 *** 。下面，我们通过大顶堆来实现。

27、基本思想：堆排序可以按照以下步骤来完成：首先将序列构建称为大顶堆；（这样满足了大顶堆那条性质：位于根节点的元素一定是当前序列的更大值）

28、 取出当前大顶堆的根节点，将其与序列末尾元素进行交换；（此时：序列末尾的元素为已排序的更大值；由于交换了元素，当前位于根节点的堆并不一定满足大顶堆的性质） 对交换后的n-1个序列元素进行调整，使其满足大顶堆的性质；

29、 重复3步骤，直至堆中只有1个元素为止下面是基于大顶堆的堆排序算法代码：

30、void print(int a[], int n){for(int j= 0; j

31、/*** 初始堆进行调整* 将H[0..length-1]建成堆* 调整完之后之一个元素是序列的最小的元素*/void BuildingHeap(int H[], int length){//最后一个有孩子的节点的位置 i= (length -1) / 2for (int i = (length -1) / 2 ; i >=0;–i)HeapAdjust(H,i,length);}/***堆排序算法*/voidHeapSort(intH[],intlength){//初始堆BuildingHeap(H,length);//从最后一个元素开始对序列进行调整for(inti=length-1;i>0;–i){//交换堆顶元素H[0]和堆中最后一个元素inttemp=H[i];H[i]=H[0];H[0]=temp;//每次交换堆顶元素和堆中最后一个元素之后，都要对堆进行调整HeapAdjust(H,0,i);}}

32、intmain{intH[10]={3,1,5,7,2,4,9,6,10,8};cout

33、}冒泡排序（Bubble Sort）算法思想：冒泡遍历所有的数据，每次对相邻元素进行两两比较，如果顺序和预先规定的顺序不一致，则进行位置交换；这样一次遍历会将更大或最小的数据上浮到顶端，之后再重复同样的操作，直到所有的数据有序。这个算法的名字由来是因为越大的元素会经由交换慢慢浮到数列的顶端。

34、算法代码：

35、void bubbleSort(int a[], int n){for(int i =0 ; ia[j+1]){inttmp=a[j];a[j]=a[j+1];a[j+1]=tmp;}}}}快速排序（QuickSort）算法思想：快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序n个项目要Ο(nlogn)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。

36、事实上，快速排序通常明显比其他Ο(nlogn)算法更快，因为它的内部循环（innerloop）可以在大部分的架构上很有效率地被实现出来快速排序使用分治法（Divideandconquer）策略来把一个串行（list）分为两个子串行（sub-lists）。算法步骤：从数列中挑出一个元素，称为基准（pivot）。重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。

37、在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

38、递归的更底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

39、算法代码：

40、voidprint(inta[],intn){for(intj=0;j

41、void swap(int *a, int *b){int tmp = *a;*a = *b;*b = tmp;}

42、int partition(int a[], int low, int high){int privotKey = a[low]; //基准元素while(low =privotKey)–high;//从high所指位置向前搜索，至多到low+1位置。

43、将比基准元素小的交换到低端swap(&a[low],&a[high]);while(low

44、void quickSort(int a[], int low, int high){if(low

45、int main{int a[10] = {3,1,5,7,2,4,9,6,10,8};cout

46、}归并排序（Merge Sort）算法思想：归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。算法步骤：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；设定两个指针，最初位置分别为两个已经排序序列的起始位置；比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；重复步骤3直到某一指针达到序列尾；将另一序列剩下的所有元素直接复制到合并序列尾。

47、算法代码：

48、void print(int a[], int n){for(int j= 0; j

49、//将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n]void Merge(ElemType *r,ElemType *rf, int i, int m, int n){int j,k;for(j=m+1,k=i; i

50、void MergeSort(ElemType *r, ElemType *rf, int lenght){int len = 1;ElemType *q = r ;ElemType *tmp ;while(len

51、int main{int a[10] = {3,1,5,7,2,4,9,6,10,8};int b[10];MergeSort(a, b, 10);print(b,10);cout

52、对新形成的序列L重复执行分配和收集元素中的十位、百位…直到分配完该序列中的更高位，则排序结束。

53、算法代码：

54、d RadixSort(Node L[],length,maxradix){int m,n,k,lsp;k=1;m=1;int temp[10][length-1];Empty(temp); //清空临时空间while(k

55、使用Python实现冒泡排序冒泡排序算法的运作如下：● 比较相邻的元素。如果之一个比第二个大，就交换他们两个。

56、● 对每一对相邻元素作同样的工作，从开始之一对到结尾的最后一对。这步做完后，最后的元素会是更大的数。● 针对所有的元素重复以上的步骤，除了最后一个。

57、● 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。以上节选自 *** 代码实现：

58、def bubble_sort(numberlist):length = len(numberlist)for i in range(length):for j in range(1, length – i):if numberlist[j – 1] >numberlist[j]:numberlist[j],numberlist[j-1]=numberlist[j-1],numberlist[j]returnnumberlist选择排序选择排序（Selectionsort）是一种简单直观的排序算法。它的工作原理如下。

59、首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。以上节选自 *** 代码实现：

60、deffindSmallest(arr):#用于查找出数组中最小的元素，返回最小元素的索引。

61、 *** allest=arr[0] *** allest_index=0foriinrange(1,len(arr)):if *** allest>arr[i]: *** allest=arr[i] *** allest_index=ireturn *** allest_index

62、defselectSort(arr):newArr=whilearr: *** allest=findSmallest(arr)newArr.append(arr.pop( *** allest))returnnewArr插入排序步骤如下:●从之一个元素开始，该元素可以认为已经被排序●取出下一个元素，在已经排序的元素序列中从后向前扫描●如果该元素（已排序）大于新元素，将该元素移到下一位置●重复步骤3，直到找到已排序的元素小于或者等于新元素的位置●将新元素插入到该位置后重复步骤2~5以上节选自 *** 代码实现:

63、definsert_sort(data):forkinrange(1,len(data)):cur=data[k]j=kwhilej>0anddata[j-1]>cur:data[j]=data[j-1]j-=1data[j]=curreturndata希尔排序希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步。然后算法再取越来越小的步长进行排序，算法的最后一步就是普通的插入排序，但是到了这步，需排序的数据几乎是已排好的了（此时插入排序较快）。

64、以上节选自 *** 代码实现：

65、defshell_sort(numberlist):length=len(numberlist)gap=length//2whilegap>0:foriinrange(gap,length):temp=numberlist[i]j=iwhilej>=gapandnumberlist[j-gap]>temp:numberlist[j]=numberlist[j-gap]j-=gapnumberlist[j]=tempgap=gap//2returnnumberlist归并排序原理如下（假设序列共有{displaystylen}个元素）：●将序列每相邻两个数字进行归并操作，形成{displaystyleceil(n/2)}个序列，排序后每个序列包含两/一个元素●若此时序列数不是1个则将上述序列再次归并，形成{displaystyleceil(n/4)}个序列，每个序列包含四/三个元素●重复步骤2，直到所有元素排序完毕，即序列数为1以上节选自 *** 代码如下：

66、defmerge(left,right):result=whileleftandright:ifleft[0]

67、def merge_sort(numberlist):if len(numberlist)

68、left = merge_sort(left)right = merge_sort(right)return merge(left, right)快速排序从数列中挑出一个元素，称为基准（pivot），● 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分割结束之后，该基准就处于数列的中间位置。这个称为分割（partition）操作。

69、● 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。● 递归到更底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

70、以上节选自 *** 代码如下：

71、def quick_sort(array):if len(array) pivot]returnquick_sort(less)+[pivot]+quick_sort(greater)堆排序若以升序排序说明，把数组转换成更大堆积(Max-HeapHeap)，这是一种满足更大堆积性质(Max-HeapProperty)的二叉树：对于除了根之外的每个节点i,A[parent(i)]≥A[i]。重复从更大堆积取出数值更大的结点(把根结点和最后一个结点交换，把交换后的最后一个结点移出堆)，并让残余的堆积维持更大堆积性质。

72、defheap_sort(numberlist):length=len(numberlist)defsift_down(start,end):root=startwhileTrue:child=2*root+1ifchild>end:breakifchild+1

73、#创建更大堆forstartinrange((length-2)//2,-1,-1):sift_down(start,length-1)

74、#堆排序forendinrange(length-1,0,-1):numberlist[0],numberlist[end]=numberlist[end],numberlist[0]sift_down(0,end-1)

75、returnnumberlist计数排序以上节选自 *** 代码如下：

76、defcounting_sort(numberlist,maxnumber):#maxnumber为数组中的更大值length=len(numberlist)#待排序数组长度b=[0foriinrange(length)]#设置输出序列，初始化为0c=[0foriinrange(maxnumber+1)]#设置技术序列，初始化为0forjinnumberlist:c[j]=c[j]+1foriinrange(1,len(c)):c[i]=c[i]+c[i-1]forjinnumberlist:b[c[j]-1]=jc[j]=c[j]-1returnb

77、总结各种排序的稳定性，时间复杂度和空间复杂度总结：我们比较时间复杂度函数的情况：

78、时间复杂度函数O(n)的增长情况所以对n较大的排序记录。

79、一般的选择都是时间复杂度为O(nlog2n)的排序 *** 。时间复杂度来说：(1)平方阶(O(n2))排序各类简单排序:直接插入、直接选择和冒泡排序；(2)线性对数阶(O(nlog2n))排序快速排序、堆排序和归并排序；(3)O(n1+§))排序,§是介于0和1之间的常数。希尔排序(4)线性阶(O(n))排序基数排序，此外还有桶、箱排序。

80、说明：当原表有序或基本有序时，直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数，时间复杂度可降至O（n）；而快速排序则相反，当原表基本有序时，将蜕化为冒泡排序，时间复杂度提高为O（n2）；原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。稳定性：排序算法的稳定性:若待排序的序列中，存在多个具有相同关键字的记录，经过排序，这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对次序发生了改变，则称该算法是不稳定的。稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，之一个键排序的结果可以为第二个键排序所用。

81、基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，可以避免多余的比较；稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序选择排序算法准则：每种排序算法都各有优缺点。因此，在实用时需根据不同情况适当选用，甚至可以将多种 *** 结合起来使用。

82、选择排序算法的依据影响排序的因素有很多，平均时间复杂度低的算法并不一定就是更优的。相反，有时平均时间复杂度高的算法可能更适合某些特殊情况。同时，选择算法时还得考虑它的可读性，以利于软件的维护。

83、一般而言，需要考虑的因素有以下四点：1．待排序的记录数目n的大小；2．记录本身数据量的大小，也就是记录中除关键字外的其他信息量的大小；3．关键字的结构及其分布情况；4．对排序稳定性的要求。设待排序元素的个数为n.1）当n较大，则应采用时间复杂度为O(nlog2n)的排序 *** ：快速排序、堆排序或归并排序序。快速排序：是目前基于比较的内部排序中被认为是更好的 *** ，当待排序的关键字是随机分布时，快速排序的平均时间最短；堆排序：如果内存空间允许且要求稳定性的，归并排序：它有一定数量的数据移动，所以我们可能过与插入排序组合，先获得一定长度的序列，然后再合并，在效率上将有所提高。

84、2）当n较大，内存空间允许，且要求稳定性=》归并排序3）当n较小，可采用直接插入或直接选择排序。直接插入排序：当元素分布有序，直接插入排序将大大减少比较次数和移动记录的次数。直接选择排序：元素分布有序，如果不要求稳定性，选择直接选择排序4）一般不使用或不直接使用传统的冒泡排序。

85、5）基数排序它是一种稳定的排序算法，但有一定的局限性：1、关键字可分解。记录的关键字位数较少，如果密集更好如果是数字时，更好是无符号的，否则将增加相应的映射复杂度，可先将其正负分开排序。总结以上所述是小编给大家介绍的必须知道的C语言八大排序算法，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。

简单有趣的c语言程序代码（几个简单有趣的c语言代码）的介绍就到这里，感觉你的阅读！