七大排序java实现

原创 2015年11月20日 09:34:33
package 七大排序;

public class Heapsort {
	public static void main(String[] args) {
		int a[]={5,4,9,8,7,6,0,1,3,2,1};
		//int[] b={5,4,9,8,7,6,0,1,3,2};数组初始化的两种等价的方式
		
		//七大排序
		heapsort(a);
		//bublesort(a);
		//mergesort(a);
		//quiksort(a,0,a.length-1);
		//selectsort(a);
		//insertsort(a);
		//shellsort(a);
		for(int i=0;i<a.length;i++){
			System.out.print(a[i]+" ");
		}
	}
	//三个比较简单的排序,排序最近每天写一遍,瞬间手写出来,在面试的时候
	
	//直接插入排序
	public static void insertsort(int[] a){
		for(int i=1;i<a.length;i++){
			int temp=a[i];
			int j=0;
			
			//核心算法位置,操作难点
			for(j=i-1;j>=0&&a[j]>temp;j--){
				a[j+1]=a[j];
			}
			a[j+1]=temp;
		}
	}
	//希尔排序,插入排序的变式,代码复杂一点
	public static void shellsort(int[] a){
		int gap=a.length/2;
		int j=0;
		while(gap>=1){//步长临界值,循环结束的标志,当步长为1之后,希尔排序的数列有序,满足我们的要求
		for(int i=gap;i<a.length;i++){
			int temp=a[i];//从步长位置向后移动
			
			//核心算法理解
			for(j=i-gap;j>=0;j=j-gap){
				if(a[j]>temp){
					a[i]=a[j];
				}else{
					break;
				}
			}
			a[j+gap]=temp;//难点:将减去的gap加上去,实现位置的交换
		}
		gap=gap/2;
		}
	}
	//选择排序
	public static void selectsort(int[] a){
		for(int i=0;i<a.length-1;i++){//注意边界条件,易错点
			int n=i;
			for(int j=i+1;j<a.length;j++){//条件起点是从第二个开始j=i+1
				if(a[j]<a[n]){//易错点!!!这里是,找到后面的最小值,不要错误的用a[i],导致出错,依次向下找
					n=j;
				}
			}
			if(a[n]!=a[i]){//交换条件比较好,防止出现相等的情况
				int temp=a[n];
				a[n]=a[i];
				a[i]=temp;
			}
		}
	}
	
	
	//归并
	public static void mergesort(int[] a){
		int mid=a.length/2;
		//拆分数组,直至都是一个
		if(a.length>1){//数组拆分递归结束的条件是都是单个元素时
			
			int[] a1=new int[mid];
			System.arraycopy(a, 0, a1, 0, mid);//注意边界,数组拷贝时,不包括mid位置的值,只是0--(mid-1),其中五个变量的位置和依据是重点
			mergesort(a1);//接着进行拆分
			
			int[] a2=new int[a.length-mid];
			System.arraycopy(a, mid, a2, 0, a.length-mid);
			mergesort(a2);
			
			int[] temp=mergearr(a1,a2);
			System.arraycopy(temp, 0, a, 0, a.length);
			
		}

		
	}
	
	public static int[] mergearr(int[] a1,int[] a2){
		int[] temp=new int[a1.length+a2.length];
		
		//以下是三个数组的索引,用于操作后面的三个数组,比较经典
		int c1=0;
		int c2=0;
		int c3=0;
		
		//排列两个有序的数组的核心算法,while 配合++ --代替for循环变得比较简单,尤其是一些逼近算法中常用
		while(c1<a1.length&&c2<a2.length){
			if(a1[c1]<a2[c2]){
				temp[c3++]=a1[c1++];
			}else{
				temp[c3++]=a2[c2++];
			}
		}
		
		while(c1<a1.length){
			temp[c3++]=a1[c1++];
		}
		
		while(c2<a2.length){
			temp[c3++]=a2[c2++];
		}
		
		return temp;
	}
	
	//快排
	public static void quiksort(int[] a,int low,int high){
		
		//没有下面的条件栈会溢出
		if(low>=high){
			return;//递归结束的条件
		}
		
		int temp=a[low];
		int i=low;
		int j=high;
		
		//核心代码区
		while(i<j){
		while(a[j]>=temp&&i<j){
			j--;
		}
		if(i<j){
		a[i++]=a[j];
		}
		while(a[i]<temp&&i<j){
			i++;
		}
		if(i<j){//没有这个条件会错过i的正确位置,可能会跑到对边上去
		a[j--]=a[i];
		}
		
		}
		a[i]=temp;
		quiksort(a,low,i-1);
		quiksort(a,i+1,high);
		
	}
	
	//冒泡排序
	public static void bublesort(int[] a){
		int temp=0;
		boolean flag=true;//用于优化算法,避免不必要的冒泡,告别简单粗暴
		
		for(int k=1;k<a.length&&flag;k++){//最差的情况是冒泡a.length-1次
			flag=false;
			for(int i=0;i<a.length-k;i++){
				if(a[i]>a[i+1]){
					temp=a[i];
					a[i]=a[i+1];
					a[i+1]=temp;
					flag=true;
				}
			}
		}
	}
	
	//堆排序优化算法如下,将根节点的编号为1,但是在数组中的存储为0的位置,这种错位在程序设计中务必要-1当调整数组元素的时候
	public static void heapsort(int[] a){
		int i;
		int len=a.length;
		
		//创建堆
		for(i=len/2;i>0;i--){
			adjustheap(a,i,len);
		}
		
		//建堆之后开头的最大值与最后一个元素对调,之后再调整
		for(i=len;i>0;i--){
			int temp=a[0];
			a[0]=a[i-1];
			a[i-1]=temp;
			adjustheap(a,1,i-1);//再次调整堆的时候,只需要考虑对调过去的根节点即可
			
		}
	}
	
	//调整堆是堆排序的核心算法部分
	public static void adjustheap(int[] a,int n,int len){

		int left=2*n;
		int right=2*n+1;
		int max=n;
		
		if(left<=len&&a[left-1]>a[max-1]){
			max=left;
		}
		
		if(right<=len&&a[right-1]>a[max-1]){
			max=right;
		}
		
		if(max!=n){
			int temp=a[n-1];
			a[n-1]=a[max-1];
			a[max-1]=temp;
			adjustheap(a,max,len);
		}
		
	}

}

MoreWindows白话经典算法之七大排序总结篇

在我的博客对冒泡排序,直接插入排序,直接选择排序,希尔排序,归并排序,快速排序和堆排序这七种常用的排序方法进行了详细的讲解,并做成了电子书以供大家下载。下载地址为:http://download.cs...
  • baolinq
  • baolinq
  • 2017年01月11日 21:36
  • 256

七大排序算法总结(含优化)

冒泡排序 #include #define N 100 using namespace std; int a[N]; void bubbleSort(int n) //冒泡排序优化 {...
  • u012432475
  • u012432475
  • 2015年06月28日 16:37
  • 632

我的js:冒泡排序算法选择排序算法以及快速排序算法。

function bubble(a) { var i = a.length, j; var tem; while (i > 0) { for (j = 0; j...
  • evilemon
  • evilemon
  • 2015年08月03日 01:27
  • 1055

java--面向对象七大设计原则

面向对象七大设计原则 1、 开闭原则 2、 里氏替换原则 3、 单一职责原则 4、 接口隔离原则 5、 依赖倒置原则 6、 迪米特原则 7、组合/聚合复用原则...
  • u013372519
  • u013372519
  • 2014年07月30日 23:40
  • 1027

七大常见排序算法总结

插入类排序 直接插入排序 希尔排序 选择类排序 简单选择排序 堆排序 交换类排序 冒泡排序 快速排序 归并类排序 归并排序...
  • lutianfeiml
  • lutianfeiml
  • 2016年07月19日 19:56
  • 5039

Java的七大设计原则

本文转自:Java设计模式遵循的七大原则 这篇文章,作者分析有深度,带给我一些启发和思考。 最近几年来,人们踊跃的提倡和使用设计模式,其根本原因就是为了实现代码的复...
  • sugaryaruan
  • sugaryaruan
  • 2015年11月19日 12:03
  • 491

七大排序算法初步实现

Sorts.h #ifndef __SORTS_H__ #define __SORTS_H__ //数据交换 void Swap(int& a, int& b); //冒泡排序 void Bub...
  • diaolingle
  • diaolingle
  • 2016年04月28日 01:01
  • 166

常见Java七大排序

排序算法
  • sinat_31057219
  • sinat_31057219
  • 2017年01月11日 21:57
  • 525

java设计的七种原则

设计的七种原则 单一职责原则:一个类只应该有一个引起它变化的原因,不要让一个类有多个引起它变化的理由。换句话说,一个类应该做和一个职责相关的业务,不要让一个类承担过多的职责。一个类做的职责越单一...
  • wang1992_1992
  • wang1992_1992
  • 2016年06月19日 16:57
  • 246

图示7大常见排序算法

此博客为转载博客,点击查看原文 1. 快速排序 介绍: 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下,排序 n 个项目要Ο(n log n)次比较。在最坏...
  • u012706792
  • u012706792
  • 2016年03月07日 10:26
  • 7151
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:七大排序java实现
举报原因:
原因补充:

(最多只允许输入30个字)