插入排序、合并排序、堆排序和快速排序

  1 * 插入排序
  2 * 时间复杂度O(n2)
  3 * @param array原地排序算法
  4 */
  5 public void insertSort(int[] array) {
  6   for (int i = 1; i < array.length; i++) {
  7     int present = array[i];
  8     int position = i;
  9     while (position > 0 &;&; array[position - 1] > present) {// 右移
 10       array[position] = array[position - 1];
 11       position--;
 12       }
 13     array[position] = present;
 14   }
 15 }
 16
 17
 18
 19 /**
 20
 21 * 合并排序
 22 * O(nlogn)
 23 * @param array
 24 * @param left 第一个索引
 25 * @param right 最后一个索引
 26 */
 27 public void mergeSort(int []array,int left,int right){
 28   if(left<right){
 29     int middle=(left+right)/2;
 30     mergeSort(array,left,middle);
 31     mergeSort(array,middle+1,right);
 32     merge(array,left,middle,right);
 33   }
 34 }
 35
 36 public void merge(int []array,int left,int middle,int right){
 37   int [] array1=new int[middle-left+1];
 38   int [] array2=new int[right-middle];
 39   for(int i=0;i<array1.length;i++){
 40     array1[i]=array[left+i];
 41   }
 42   for(int i=0;i<array2.length;i++){
 43     array2[i]=array[middle+i+1];
 44   }
 45   int l=0,r=0,k=left;
 46   for(;k<=right&;&;l<array1.length&;&;r<array2.length;k++){
 47     if(array1[l]>array2[r]){
 48       array[k]=array2[r];
 49       r++;
 50     }else {
 51       array[k]=array1[l];
 52       l++;
 53     }
 54   }
 55   while(l<array1.length){
 56     array[k]=array1[l];
 57       l++;
 58       k++;
 59     }
 60    while(r<array2.length){
 61     array[k]=array2[r];
 62     r++;
 63     k++;
 64    }
 65 }
 66
 67
 68
 69 /**
 70 * 堆排序
 71 * 原地排序且O(nlogn)
 72 * @param array
 73 */
 74 public void heapSort(int [] array){
 75   buildHeap(array);
 76   for(int i=array.length-1;i>0;i--){
 77     int k=array[0];
 78     array[0]=array[i];
 79     array[i]=k;
 80     heapify(array, 0, i);
 81   }
 82 }
 83 /**
 84 * 构建最大堆
 85 * @param array
 86 */
 87 public void buildHeap(int [] array){
 88   for(int i=array.length/2-1;i>-1;i--){
 89     heapify(array,i,array.length);
 90   }
 91 }
 92
 93 /**
 94 *
 95 * @param array 数组
 96 * @param index 数组中的索引
 97 * @param length 树中元素个数
 98 */
 99 public void heapify(int [] array,int index,int length){
100   int present=index;//当前索引
101   int value=array[index];
102   int largest=array[index];
103   int largest_index=index;
104   while((2*present+1)<length){//判断是否有儿子
105     if(array[2*present+1]>largest){
106     largest=array[2*present+1];
107     largest_index=2*present+1;
108   }
109   if((2*present+2)<length&;&;array[2*present+2]>largest){
110     largest=array[2*present+2];
111     largest_index=2*present+2;
112   }
113   if(largest_index!=present){
114     array[present]=largest;
115     present=largest_index;
116     largest=value;
117   }else{
118     break;
119   }
120   }
121   array[present]=value;
122}
123
124
125
126 /**
127 * 最坏时间O(n2)----在数组已经排好序时发生
128 * O(nlogn)
129 * @param array
130 * @param p
131 * @param r
132 */
133 public void quickSort(int []array,int p,int r){
134   if(p<r){
135     int q=partition(array,p,r);
136     quickSort(array,p,q-1);
137     quickSort(array,q+1,r);
138   }
139 }
140
141 public int partition(int []array,int p,int r){
142   Random random=new Random();
143   exchange(array,r,random.nextInt(r-p+1)+p);//随机取数
144   int x=array[r];
145   int i=p-1;
146   for(int j=p;j<r;j++){
147     if(array[j]<=x){
148     i=i+1;
149     exchange(array,i,j);
150   }
151 }
152   exchange(array,i+1,r);
153   return i+1;
154 }
155
156 public void exchange(int []array,int p,int q){
157   int k=array[p];
158   array[p]=array[q];
159   array[q]=k;
160 }

原文地址:https://www.cnblogs.com/hunrry/p/9183489.html

时间: 2024-10-11 20:48:41

插入排序、合并排序、堆排序和快速排序的相关文章

3种sort:insertion_sort,merge_sort,quick_sort 插入排序 合并排序 快速排序

插入排序,普通排序 一般 前端够用,样本容量小于1000,根本看不出性能问题 function insertion_sort(arr){ var len=arr.length; for(var j=1;j<len;j++){ var key=arr[j]; var i=j-1; while(i>=0&&arr[i]>key){ arr[i+1]=arr[i]; i=i-1; } arr[i+1]=key; } } 合并排序 merge_sort function _mer

算法导论学习之插入排序+合并排序

最近准备花时间把算法导论详细的看一遍,强化一下算法和数据结构的基础,将一些总结性的东西写到博客上去. 一.插入排序 算法思想:如果一个数组A,从A[1–n-1]都是有序的,然后我们将A[n]插入到A[1–n-1]的某个合适的位置上去那么就可以保证A[1–n]都是有序的.这就是插入排序的思想:具体实现的时候我们将数组的第一个元素看出有序,然后从第二个元素开始按照上面的步骤进行插入操作,直到插入最后一个元素,然后整个数组都是有序的了. 时间复杂度分析:代码中有两重for循环,很容易看出时间复杂度是n

算法有插入排序,堆排序,合并排序,快速排序和stooge排序

比较的算法有插入排序,堆排序,合并排序,快速排序和stooge排序, 先说一下比较结果 1,比较插入和stooge排序,stooge的表现如此之差,数组大小在2000时 InsertSort VS StoogeSort 's Running Time:     16ms:47672ms; Terribly! Isn't It? 所以在后面的比较中,没有带stooge这个垃圾算法 2,插入排序,堆排序,合并排序,快速排序运行时间对比 (网易博客的表格功能太差了,不爽,只好以文本对齐展现给大家了):

各种常见的排序,冒泡排序,选择排序,插入排序,希尔排序,堆排序,快速排序,基数排序,桶排序

各种常见的排序 要开始找工作了,把以前学的各种小知识复习一遍,以下是各种常见的排序的简单实现(冒泡排序,选择排序,插入排序,希尔排序,堆排序,快速排序,基数排序,桶排序),至于原理就不写出来了,代码比较简单,看一下就懂,再不行可以随意找本书或百度! #include <iostream> using namespace std; // 冒泡 void BubbleSort(int data[], int length) { if(data == NULL || length <= 0)

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

以下是最近学习各种算法的代码实现: #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(*

七大排序算法(冒泡,选择,插入,希尔,快速,合并,堆排序)的java实现

冒泡排序 思路:就是每次将最大或最小的元素放到数组的最后,so easy!时间复杂度为(O(n^2)) public class BubbleSort { public static void bubbleSort(int[] a) { for (int j = 1; j < a.length; j++) { for (int i = 0; i < a.length - j; i++) { if (a[i] > a[i + 1]) { int temp = a[i]; a[i] = a[

使用合并排序和快速排序对字符串按长度排序

前段时间要对字符串集合进行按长度排序,字符串长度长的排在队列前面,最短的排在最后,可以使用两种排序方法进行排序,其中快速排序的效能会好些,但快速排序在字符串的集合非常大的时候,有时会得不到正确的结果,具体原因还不清楚. 1.合拼排序的代码 using System; using System.Collections.Generic; using System.Text; namespace FtpproxyDownRule.DBUtility { public class sortbyStrin

递归与分治-合并排序、快速排序以及循环赛问题

合并排序 合并排序法是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的.然后再把有序子序列合并为整体有序序列. 递归方法: 基本思想是:将待排序元素分成大小一致相同的2个子集和,分别对两个子集和进行排序,最终将排好序的子集合并成所需要的排好序的集合 package com.gqx.arithmetic.Recursion; public class Recursion_Merge2 { private static void mergeSort(

C# 插入排序 冒泡排序 选择排序 高速排序 堆排序 归并排序 基数排序 希尔排序

以下列出了数据结构与算法的八种基本排序:插入排序 冒泡排序 选择排序 高速排序 堆排序 归并排序 基数排序 希尔排序,然后是測试的样例.代码位置:http://download.csdn.net/detail/luozuolincool/8040027 排序类: public class Sortings { //插入排序 public void insertSort(int[] array) { int temp = 0; int index = 0; for (int i = 0; i <