qsort,mergesort,插入排序

 1     //插入排序
 2     int a[n];
 3     for(int i=2;i<=n;i++)
 4     {
 5         int s=a[i];
 6         int j=i-1;
 7         while(j&&a[j]>a[i])
 8         {
 9             a[j+1]=a[j];
10             j--;
11         }
12         a[j+1]=s;
13     }
14
15
16 int part(int a[],int low,int high)
17 {
18     int tmp=a[low];
19     while(low<high)
20     {
21         while(low<high&&a[high]>=tmp)
22             high--;
23         if(low<high)
24         {
25             a[low]=a[high];
26             low++;
27         }
28         while(low<high&&a[low]<=tmp)
29             low++;
30         if(low<high)
31         {
32             a[high]=a[low];
33             high--;
34         }
35     }
36     a[low]=tmp;
37     return low;
38 }
39
40 void quick_sort(int a[],int low,int high)
41 {
42     int mid;
43     if(low<high)
44     {
45         mid=(low+high)/2;
46         mid=part(a,low,high);
47         quick_sort(a,low,mid-1);
48         quick_sort(a,mid+1,high);
49     }
50     return ;
51 }
52
53 /************归并************/
54 void merge(int a[],int low,int high)
55 {
56     int b1=low;
57     int mid=(low+high)/2;
58     int b2=mid+1;
59     int len=high-low+1;
60     int *b,k=0;
61     b=(int *)malloc(len*sizeof(int));
62     while(b1<=mid&&b2<=high)
63     {
64         if(a[b1]<=a[b2])
65             b[k++]=a[b1++];
66         else
67             b[k++]=a[b2++];
68     }
69     while(b1<=mid)
70         b[k++]=a[b1++];
71     while(b2<=high)
72         b[k++]=a[b2++];
73     for(int i=0;i<len;i++)
74         a[low++]=b[i];
75     free(b);
76 }
77
78 void merge_sort(int a[],int low,int high)
79 {
80     int mid=(low+high)/2;
81     if(low<high)
82     {
83         merge_sort(a,low,mid);
84         merge_sort(a,mid+1,high);
85         merge(a,low,high);
86     }
87     return ;
88 }
时间: 2024-10-11 07:52:30

qsort,mergesort,插入排序的相关文章

【优化王牌】二分查找

二分查找    二分法?多简单?NO!NO!NO!我们可不是讲俗透顶的二分查找!我们讲的是二分查找的应用!      我们讲的也不是二分答案,是优化.      你真的会充分地用二分查找吗?      事实告诉你:含序列题目并可以暴力等求出答案的,基本上二分查找都是可以将其优化的!      不信?咱们来看看一道简单的排序: MZA 的排序 [问题描述]   现在知道 MZA 有一堆同学,也不知道有多少个. 可恶的 MZA 现在给了你这堆同学的名字和成绩(都是英文名字),请你输出他们的成绩排序.

一些数组排序算法的简单实现(冒泡、插入、希尔、归并和qsort)

#include <stdlib.h> #include <string.h> #include "sort.h" //冒泡排序 int bubbleSort(int a[], int n) { int i, j; for (i=n-1; i>=0; i--) { for (j=0; j<i; j++) { if (a[j]>a[j+1]) {//交换a[i]和a[j],也可使用临时变量实现 a[j] += a[j+1]; a[j+1] = a

七大内部排序算法总结(插入排序、希尔排序、冒泡排序、简单选择排序、快速排序、归并排序、堆排序)

 写在前面: 排序是计算机程序设计中的一种重要操作,它的功能是将一个数据元素的任意序列,重新排列成一个按关键字有序的序列.因此排序掌握各种排序算法非常重要.对下面介绍的各个排序,我们假定所有排序的关键字都是整数.对传入函数的参数默认是已经检查好了的.只是简单的描述各个算法并给出了具体实现代码,并未做其他深究探讨. 基础知识: 由于待排序的记录数量不同,使得排序过程中设计的存储器不同,可将排序方法分为两大类:一类是内部排序,指的是待排序记录存放在计算机随机存储器中进行的排序过程.另一类是外部排序,

基本排序算法(冒泡排序 选择排序 插入排序 快速排序 归并排序 基数排序 希尔排序)

冒泡排序 public static void bubbleSort(int[] arr){ int lgn = arr.length; for (int i = 0; i < lgn - 1; i++) { for (int j = 0; j < lgn - 1 - i; j++) { if(arr[j] > arr[j + 1]){ int temp = arr[j + 1]; arr[j + 1] = arr[j]; arr[j] = temp; } } } } 选择排序 publ

插入排序 | 冒泡排序 | 希尔排序 | 堆排序 | 快速排序 | 选择排序 | 归并排序

以下是最近学习各种算法的代码实现: #include <stdlib.h> #include <stdio.h> #include <time.h> #include <limits.h> typedef int EleType; typedef int (*CompFunc)(void *,void *); int IntComp(void * a,void *b) { if(*(int *)a > *(int *)b) return 1; if(*

【算法基础】由插入排序来看如何分析和设计算法

插入排序及其解决思路 算法的作用自然不用多说,无论是在校学生,还是已经工作多年,只要想在计算机这条道路走得更远,算法都是必不可少的. 就像编程语言中的"Hello World!"程序一般,学习算法一开始学的便是排序算法.排序问题在日常生活中也是很常见的,说得专业点: 输入是:n个数的一个序列<a1,a2,...,an?1,an> 输出是:这n个数的一个全新的序列<a,1,a,2,...,a,n?1,a,n>,其特征是a,1≤a,2≤...≤a,n?1≤a,n 举

测试std::sort 和std::qsort 的性能, 修改编译器栈大小

根据effective STL中Item 46 提到, C程序员很难接受C++的STL中std::sort(定义于头文件<algorithm>)竟然比C语言的std::qsort(定义与头文件<cstdlib>中)快了670%. 最后Scot Meyer建议我们我们要使用C++的std::sort函数. 我们知道qsort 实现的排序算法是快排, 但是std::sort 实现的排序算法并不知道, 有人说这得看是哪一个STL版本了. std::sort的大部分实现的是quick so

常见排序集合(冒泡排序,选择排序,直接插入排序,二分插入排序,快速排序,希尔排序,归并排序)

一下是一些常见的排序算法: 交换元素(后面算法都有用到): // 交换元素 private static void swap(int[] a, int i, int j) { int temp; temp = a[i]; a[i] = a[j]; a[j] = temp; } 冒泡排序(有优化): // 冒泡排序(优化①,②,③,④) private static void bubbleSort(int[] a) { boolean flag = false;// ①表示整个序列是无序的 for

归并排序(MergeSort)

和分治思想的第一次相遇 当问题的规模是可以划分的时候,分治的算法往往是很有效的: 不断分割问题的规模,直到子问题的规模足够小便直接求解,之后不断整合子问题的解得到更大规模的解,最后得到完全解. 归并排序就是分治算法的一个简单的例子. 可能有人觉得快速排序也是属于分治算法,但我不这么觉得,因为快速排序是先得到大问题的解的一部分,再靠子问题来完成解, 并没有整合子问题这一步,所以硬要说的话,快速排序应该是"治分"算法. 简单图示(是不是有点太简单了) 如何分解? 归并排序把问题划为均匀的两