Java版本插入排序、希尔排序、堆排序、归并排序、快速排序、桶排序、基数排序、外部排序

最新推荐文章于 2021-04-01 09:05:16 发布

原创最新推荐文章于 2021-04-01 09:05:16 发布 · 295 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Java版本插入排序、希尔排序、堆排序、归并排序、快速排序、桶排序、基

知识点及原理分析同时被 2 个专栏收录

59 篇文章

订阅专栏

算法

5 篇文章

订阅专栏

本文深入探讨了Comparable与Comparator接口的区别，通过实例演示了如何使用这两种比较方式来进行对象排序。同时，文章还介绍了插入排序、希尔排序和归并排序等经典排序算法，并提供了代码实现。

在写算法前先搞清楚

对于Comparable意思是说：可以与此对象进行比较的那些对象的类型，
此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。
而Comparator则是T - 此 Comparator 可以比较的对象类型，它是强行对某个对象 collection 进行整体排序的比较函数。

区别：

Comparable 用作默认的比较方式。
Comparator 用作自定义的比较方式，当默认的比较方式不适用时或者没有提供默认的比较方式，使用Comparator就非常有用。
Comparator
强行对某个对象collection进行整体排序的比较函数，可以将Comparator传递给Collections.sort或Arrays.sort。
Comparable
强行对实现它的每个类的对象进行整体排序，实现此接口的对象列表（和数组）可以通过Collections.sort或Arrays.sort进行自动排序。


实例（Comparator）：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.TreeSet;
import org.junit.Test;
public class AdandDomainSizeCompare {
  
 @Test
 public void test(){
  List<AdandDomain> l = new ArrayList<AdandDomain>();
  AdandDomain ad1 = new AdandDomain("str1",1.0);
  AdandDomain ad2 = new AdandDomain("str3",5.0);
  AdandDomain ad3 = new AdandDomain("str2",3.0);
  l.add(ad3);
  l.add(ad2);
  l.add(ad1);
  Collections.sort(l, new cpta());//使其从高到低进行排序
  System.out.println(l.get(0).average+" "+l.get(1).average+" "+l.get(2).average);
 }
}
class AdandDomain{
 String domain;
 double average;
 public AdandDomain(String domain,double average){
  this.domain = domain;
  this.average = average;
 }
}
class cpta implements Comparator<AdandDomain>{
 @Override
 public int compare(AdandDomain o1, AdandDomain o2) {
  if(o1.average-o2.average>0){
   return 1;
  }else if(o1.average-o2.average<0){
   return -1;
  }
  return 0;
 }
}
实例（Comparable）：

 import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.TreeSet;
import org.junit.Test;
public class AdandDomainSizeComparable {
  
 @Test
 public void test(){
  Date date = new Date();
  int d = date.compareTo(new Date());
  System.out.println(d);
  List<AdandDomain> l = new ArrayList<AdandDomain>();
  AdandDomain ad1 = new AdandDomain("str1",1.0);
  AdandDomain ad2 = new AdandDomain("str3",5.0);
  AdandDomain ad3 = new AdandDomain("str2",3.0);
  l.add(ad3);
  l.add(ad2);
  l.add(ad1);
  int compareTo = ad2.compareTo(ad3);//表明这个类的对象之间是可以相互比较的
  System.out.println(compareTo);
  Object[] array = l.toArray();
  AdandDomain[] dd = {ad1,ad3,ad2,ad3};
  Arrays.sort(array);
  Collections.sort(l);
  System.out.println(l.get(0).average+" "+l.get(1).average+" "+l.get(2).average);
 }
}
class AdandDomain implements Comparable<AdandDomain>{
 String domain;
 double average;
 public AdandDomain(String domain,double average){
  this.domain = domain;
  this.average = average;
 }
 @Override
 public int compareTo(AdandDomain o) {
  if(this.average-o.average>0){
   return 1;
  }else if(this.average-o.average<0){
   return -1;
  }
  return 0;
 }
}
此外我们也可以使用一些构造函数中使用了比较器的集合例如 TreeSet

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.TreeSet;
import org.junit.Test;
public class AdandDomainSizeComparetree {
  
 @Test
 public void test(){
 //在集合里面使用比较器按照自己规定的顺序，进行排序
  TreeSet<AdandDomain> set = new TreeSet<AdandDomain>(new cpta());
  set.add(ad1);
  set.add(ad2);
  set.add(ad3);
  System.out.println(set.first().average+" "+ set.last().average);
 }
}
class AdandDomain{
 String domain;
 double average;
 public AdandDomain(String domain,double average){
  this.domain = domain;
  this.average = average;
 }
}
class cpta implements Comparator<AdandDomain>{
 @Override
 public int compare(AdandDomain o1, AdandDomain o2) {
  if(o1.average-o2.average>0){
   return 1;
  }else if(o1.average-o2.average<0){
   return -1;
  }
  return 0;
 }
}

插入排序

最简单的排序算法之一是插入排序（insertion sort)。插入排序由N-1趟排序组成
插入排序的时间复杂度:O(n^2)
插入排序顾名思义，就是在排序的过程中，把数组的每一个元素按照大小关系，插入到前面有序区的对应位置。
比如下面数组中的元素3，按照大小关系，需要插入到前面有序区三个元素之前，而前面三个元素则相应向后挪动：
在这里插入图片描述

代码实现：

package sort;

public class InsertSort {

	public static <AnyType extends Comparable<? super AnyType>>
	void insertionSort(AnyType[] a) {
		int j;
		for(int i=1; i<a.length;i++) {
			AnyType temp = a[i];
			for(j = i;j>0 && temp.compareTo(a[j-1])<0;j--) {
				a[j] =a[j-1];
			}
			a[j] = temp;
		}
	}
}

希尔排序

希尔排序又称缩减增量排序
希尔排序平均复杂度：O(n3/2) 最坏:O(n^2)

在这里插入图片描述


```java
package sort;

public class ShellSort {
   public static <AnyType extends Comparable<? super AnyType>> void shellsort(AnyType[] a) {
	   int j;
	   for(int gap = a.length/2;gap>0;gap/=2) {
		   for(int i =gap;i<a.length;i++) {
			   AnyType temp =a[i];
			   for(j =i;j>=gap && temp.compareTo(a[j-gap]) < 0;j-=gap) {
				   a[j]=a[j-gap];
			   }
			   a[j] = temp;
		   }
	   }
   }
}

归并排序

public class BinarySearchNoRecur {

	public static void main(String[] args) {
		//测试
		int[] arr = {1,3, 8, 10, 11, 67, 100};
		int index = binarySearch(arr, 100);
		System.out.println("index=" + index);//
	}
	
	//二分查找的非递归实现
	/**
	 * 
	 * @param arr 待查找的数组, arr是升序排序
	 * @param target 需要查找的数
	 * @return 返回对应下标，-1表示没有找到
	 */
	public static int binarySearch(int[] arr, int target) {	
		int left = 0;
		int right = arr.length - 1;
		while(left <= right) { //说明继续查找
			int mid = (left + right) / 2;
			if(arr[mid] == target) {
				return mid;
			} else if ( arr[mid] > target) {
				right = mid - 1;//需要向左边查找
			} else {
				left = mid + 1; //需要向右边查找
			}
		}
		return -1;
	}
}