排序算法Java实现

比较排序

冒泡排序

思想：

//冒泡排序
class test1{
	public static int[] bubbleSort(int[]sort){
		for (int i = 0; i < sort.length; i++) {
			for (int j = 0; j < sort.length-i-1; j++) {
				if(sort[j]>sort[j+1]) {
					int temp=sort[j];
					sort[j]=sort[j+1];
					sort[j+1]=temp;
				}
				
			}
		}
		return sort;
	}
public static void main(String[] args) {
	int [] unsort= {6,5,4,3,2};
	int [] sort=bubbleSort(unsort);
	for (int i = 0; i < sort.length; i++) {
		System.out.println(sort[i]);
	}
}
}

算法复杂度分析：最好时间复杂度O(n^2),最坏时间复杂度为：O(n方），空间复杂度O(1).

快速排序

class test1{
	public static int []quicksort(int[] sort,int low,int high){
		if(low>high||sort==null||low<0||high<0)return null; 
		int start=low;
		int end=high;
		int flag=sort[low];
		while(start<end) {
			while(start<end&&sort[end]>flag){
				end--;
			}
			int temp=sort[end];
			sort[end]=sort[start];
			sort[start]=temp;
			while(start<end&&sort[start]<flag){
				start++;
			}
			int temp2=sort[end];
			sort[end]=sort[start];
			sort[start]=temp2;
		}
		if(start>low)quicksort(sort,low,start-1);
		if(end<high)quicksort(sort,end+1,high);
		return sort;
	}
	public static void main(String[] args) {
		int [] unsort= {6,5,4,3,2};
		int start=0;
		int end=unsort.length-1;
	int [] sort=quicksort(unsort,start,end);
	for (int i = 0; i < sort.length; i++) {
		System.out.println(sort[i]);
	}
}
}

算法复杂的分析：不稳定，在一个序列是完全正序或完全反序的情况，变成冒泡排序，复杂度为O(n^2)。
。

归并排序

思路

将一个数组进行对半，数组规模变小，重复该过程，直到元素个数为1，一个元素是排好序的。
然后就是合并的过程，开始合并两个元素，然后四个、八个。该算法是分治算法的典型实现。

package duanxin;
 class new_name
{   
	 public static int[] sort(int[] a,int low,int high,int []temp){
	        int mid = (low+high)/2;
	        if(low<high){
	            sort(a,low,mid,temp);
	            sort(a,mid+1,high,temp);
	            //左右归并
	            merge(a,low,mid,high,temp);
	        }
	        return a;
	    }
	     
	    public static void merge(int[] a, int low, int mid, int high,int temp[]) {
	        int i= low;
	        int j = mid+1;
	        int k=0;
	        // 把较小的数先移到新数组中
	        while(i<=mid && j<=high){
	            if(a[i]<a[j]){
	                temp[k++] = a[i++];
	            }else{
	                temp[k++] = a[j++];
	            }
	        }
	        // 把左边剩余的数移入数组 
	        while(i<=mid){
	            temp[k++] = a[i++];
	        }
	        // 把右边边剩余的数移入数组
	        while(j<=high){
	            temp[k++] = a[j++];
	        }
	        // 把新数组中的数覆盖nums数组
	        for(int x=0;x<high-low+1;x++){
	            a[x+low] = temp[x];
	        }
	    }
    public static void main(String[] args) {
    	 int array[]= {12,6,3,2,1,7,9};
    	 int[] temp = new int[array.length];
    	int [] sort=sort(array,0,array.length-1,temp);
    	for (int i = 0; i < sort.length; i++) {
    		System.out.println(sort[i]);
			
		}
		}
}

稳定算法，其时间复杂度固定。
算法复杂度分析：no（log2n）。

选择排序

思路

在数组中找到最小的元素的位置与第一个元素交换，然后将不包括第一个元素外的元素继续按照上述方式比较。

package test1;

class test1{
public static int[] choosesort(int[]array) {
	for (int i = 0; i < array.length; i++) {
		int k=i;
		for (int j = i+1; j < array.length; j++) {
			if(array[i]>array[j]) {
				k=j;
			}	
		}
		int temp=array[i];
		array[i]=array[k];
		array[k]=temp;
		}
	return array;
}	
	public static void main(String[] args) {
		int[]array= {6,4,2,6,7};
		int[]sortarray=choosesort(array);
		for (int i = 0; i < sortarray.length; i++) {
			System.out.println(sortarray[i]);
		}

	}
}

插入排序（不稳定）

package test1;

class test1{
    public static void insertsort(int []array) {
    	int j=0;
    	for (int i = 0; i < array.length; i++) {
    		int temp=array[i];
			for (j = i; j >0&&array[j-1]>temp; j--) {
					array[j]=array[j-1];
			}
			array[j]=temp;
		}
    	for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}    
    }
	public static void main(String[] args) {
		int[]array= {4,6,3,1,2};
		insertsort(array);
	}
}

复杂度O（n^2）.

希尔排序

思路

希尔排序：在直接插入排序的基础上进行的优化，直接插入排序在n值小的时候效率比较高，在n很大的时候如果待排序序列基本有序，效率依然很高，时间效率可以提升为O(n)。希尔排序也称之为缩小增量排序。

package duanxin;
 class new_name
{   private static void shellSort(int[] a){
	        int n=a.length;
	        int gap=n/2;
	        while(gap>=1){
	            for(int i=gap;i<a.length;i++){
	                int j=0;
	                int temp = a[i];
	                for(j=i-gap;j>=0 && temp<a[j];j=j-gap){
	                    a[j+gap] = a[j];
	                }
	                a[j+gap] = temp;
	            }
	            for (int i = 0; i < a.length; i++) {
					System.out.println(a[i]);
				}
	            gap = gap/2;
	        }
	    }
    public static void main(String[] args) {
    	 int array[]= {12,6,3,2,1,7,8,7};
    	 shellSort(array);	
		}	
		}

堆排序（选择）

思想：堆排序就是利用堆(假设进行升序，也就是使用大顶堆)进行排序的方法。它的基本思想是，将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根结点。将其与堆数组的末尾元素交换，此时末尾元素就是最大值，然后将剩余的 n - 1 个序列重新构造成一个堆，这样就得到 n - 1个元素中的次大值。如此反复执行， 便能得到一个有序序列了 。

• 完全二叉树
  若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。
  完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。
  一棵二叉树至多只有最下面的两层上的结点的度数可以小于2，并且最下层上的结点都集中在该层最左边的若干位置上，则此二叉树成为完全二叉树。

• 大根堆：所有节点（n）都比他的左孩子（2n+1）与右孩子（2n+2）大的完全二叉树。

• 小根堆：所有节点（n）都比他的左孩子（2n+1）与右孩子（2n+2）小的完全二叉树。

非比较排序

非比较排序引用

桶排序

桶排序在海量数据中的应用
桶排序 可用于最大最小值相差较大 的数据情况，比如[9012,19702,39867,68957,83556,102456]。
但桶排序要求数据的分布必须均匀，否则可能导致数据都集中到一个桶中。比如[104,150,123,132,20000], 这种数据会导致前4个数都集中到同一个桶中。导致桶排序失效。
？？（代码存在问题了）(https://www.cnblogs.com/zer0Black/p/6169858.html)

计数排序

• 计数排序需要占用大量空间，它仅适用于数据比较集中的情况。比如 [0～100],[10000~19999]。
• 算法流程：
  需要三个数组:
  待排序数组 int[] arr = new int[]{4,3,6,3,5,1};
  辅助计数数组 int[] help = new int[max - min + 1]; //该数组大小为待排序数组中的最大值减最小值+1
  输出数组 int[] res = new int[arr.length];
  1.求出待排序数组的最大值max=6， 最小值min=1
  2.实例化辅助计数数组help，help数组中每个下标对应arr中的一个元素，help用来记录每个元素出现的次数
  3.计算 arr 中每个元素在help中的位置 position = arr[i] - min，此时 help = [1,0,2,1,1,1]; （3出现了两次，2未出现）
  4.根据 help 数组求得排序后的数组，此时 res = [1,3,3,4,5,6]

package duanxin;
 class new_name
{   private static void countSort(int[] a){
	        int min=Integer.MAX_VALUE;
	        int max=Integer.MIN_VALUE;
	        int loc;
	        if(a==null||a.length==0)return ;
	        for (int i = 0; i < a.length; i++) {
	        	min=Math.min(min,a[i]);
	        	max=Math.max(max, a[i]);
			}
	        int[]temp=new int[max];
	        for (int i = 0; i < a.length; i++) {
	        	loc=a[i]-min;
	        	temp[loc]=temp[loc]+1;
			}
	        int index=0;
	        for (int i = 0; i < temp.length; i++) {
				while(temp[i]-->0) {
					a[index++]=i+min;
				}
			}
	        for (int z = 0; z < a.length; z++) {
	        	System.out.println(a[z]);
			}
	    }
    public static void main(String[] args) {
    	 int array[]= {12,6,3,2,1,7,8,7};
    	 countSort(array);
		}	
	}

比较排序与非比较排序的区别

常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。
在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置 。 在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logN次，所以时间复杂度平均O(nlogn)。
比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序。可以说，比较排序适用于一切需要排序的情况。

计数排序、基数排序、桶排序则属于非比较排序。非比较排序是通过确定每个元素之前，应该有多少个元素来排序。针对数组arr，计算arr[i]之前有多少个元素，则唯一确定了arr[i]在排序后数组中的位置。
非比较排序只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。算法时间复杂度O(n)。 非比较排序时间复杂度底，但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。