JAVA 经典排序算法

首先创建一个数据类：

public class DataWrap  implements Comparable<DataWrap>{

	int data;
	String flag;
	public DataWrap(int data,String flag){
		this.data=data;
		this.flag=flag;
	}
	public String toString(){
		return data+flag;

	}
	@Override
	public int compareTo(DataWrap W) {
		// TODO Auto-generated method stub
		return this.data>W.data?1:(this.data==W.data?0:-1);
	}

}

①二分查找排序算法：

import java.util.Arrays;


public class BinaryInsertSort {


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		DataWrap data[]={
				new DataWrap(15, ""),
				new DataWrap(20, ""),
				new DataWrap(-15,""),
				new DataWrap(9, "*")
		};
		System.out.println("排序前：\n"+Arrays.toString(data));
		BinaryInsertSort(data);
		System.out.println("排序后：\n"+Arrays.toString(data));


	}


	public static void BinaryInsertSort(DataWrap[] data) {
		// TODO Auto-generated method stub
		System.out.println("开始排序：\n");
		int lenghts=data.length;
		for(int i=1;i<lenghts;i++){
			//当整体后移时，保证data[i]的值不会丢失
			DataWrap temp=data[i];
			int low=0;
			int high=i-1;
			while(low<=high){
				//找出low，hig中间的索引
				int mid=(low+high)/2;
				if(temp.compareTo(data[mid])>0){
					//限制在索引大于mid的那一半中搜索
					low=mid+1;
				}
				else {
					//限制在索引小于mid那一半搜索
					high=mid-1;
				}
			}
			//将low到i处所有元素向后整体移一位
			for(int j=i;j>low;j--){
				
				data[j]=data[j-1];
			}
			//最后将temp的值插入合适的位置
			data[low]=temp;
			System.out.println(Arrays.toString(data));
		}
		
	}


}

②冒泡排序算法

import java.util.Arrays;


public class BubbleSort {


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		DataWrap[] data={
				
				new DataWrap(12, ""),
				new DataWrap(5, ""),
				new DataWrap(64, "*"),
				new DataWrap(12, ""),
				new DataWrap(-12, "")
		};
		System.out.println("排序前：\n"+Arrays.toString(data));
		BubbleSort(data);
		System.out.println("排序后\n"+Arrays.toString(data));


	}


	public static void BubbleSort(DataWrap[] data) {
		// TODO Auto-generated method stub
		int lengths=data.length;
		System.out.println("开始排序：\n");
		
		for (int i = 0; i < data.length-1; i++) {
			boolean f=false;
			for(int j=0;j<lengths-1-i;j++){
				if(data[j].compareTo(data[j+1])>0){
					DataWrap tempDataWrap=data[j];
					data[j]=data[j+1];
					data[j+1]=tempDataWrap;
					f=true;
				}
			}
			System.out.println(Arrays.toString(data));
			//如果没有发生交换，则处于有序状态
			if(!f){
				break;
			}
			
		}
		
	}


}

③插入排序算法

import java.util.Arrays;


public class InsertSort {
	public static void main(String[] args) {
	DataWrap[] data={
			new DataWrap(12, ""),
			new DataWrap(5, "*"),
			new DataWrap(64, ""),
			new DataWrap(-14, ""),
			new DataWrap(60, ""),
			new DataWrap(0, "")
	};
	
	System.out.println("排序前：\n"+Arrays.toString(data));
	
	InsertSort(data);
	
	System.out.println("排序后：\n"+Arrays.toString(data));
	
	}
	public static void InsertSort(DataWrap[] data) {
		// TODO Auto-generated method stub
		System.out.println("开始排序：\n");
		int lengths=data.length;
		for(int i=1;i<lengths;i++){
			
			//当整体后移时，保证data[i]的值不会丢失
			
			DataWrap tem=data[i]; 
			
			//i索引处的值已经比前面的所有值都大，表明已经有序，无需插入
			
			//i索引处之前的数据已经有序，i-1索引处元素的值就是最大值
			
			
			
			if(data[i].compareTo(data[i-1])<0){
				
				int j=i-1;
				
				//整体后移一格
				
				for(;j>=0 && data[j].compareTo(tem)>0;j--){
					
					data[j+1]=data[j];
					
				}
				
				//最后将tem的值插入合适位置
				
				data[j+1]=tem;
			}
		}
	}
}

④快速排序算法

import java.util.Arrays;


public class QuickSort {


	public static void main(String[] args) {
		DataWrap[] data={
				new DataWrap(36, ""),
				new DataWrap(12, "*"),
				new DataWrap(4, ""),
				new DataWrap(-14, "*"),
				new DataWrap(21, ""),
				new DataWrap(1, "")
		};
		System.out.println("排序前"+Arrays.toString(data));
		QuickSort(data);
		System.out.println("排序后："+Arrays.toString(data));
		


	}


	public static void QuickSort(DataWrap[] data) {
		// TODO Auto-generated method stub
		
		subsort(data,0,data.length-1);
		
		
	}


	public static void subsort(DataWrap[] data, int start, int end) {
		// TODO Auto-generated method stub
		//需要排序的情况
		if(start<end){
			//以第一个元素作为分界值
			DataWrap base=data[start];
			
			//i从左边开始搜索，搜索大于分界值的元素
			int i=start;
			//j从右边开始搜索，搜索小于分界值的元素
			int j=end+1;
			
			while(true){
				//找到大于分界值的元素的索引，或者i已经到了end处
				while(i<end && data[++i].compareTo(base)<=0);
				//找到小于分界值的元素的索引，或者j已经到了开始处
				while(j>start && data[--j].compareTo(base)>=0);
				if(i<j){
					swap(data, i,j);
				}
				else{
					break;
				}
				System.out.println(Arrays.toString(data));
			}
			swap(data,start,j);
			//递归左子序列
			subsort(data, start, j-1);
			//递归右子序列
			subsort(data, j+1, end);
		}
		
	}


	public static void swap(DataWrap[] data, int i, int j) {
		// TODO Auto-generated method stub
		DataWrap tempDataWrap=data[i];
		data[i]=data[j];
		data[j]=tempDataWrap;
		
	}


}

⑤选择排序算法

import java.util.Arrays;


public class SelectSort {
	
	


	public static void main(String[] args) {
		DataWrap[] data={
			new DataWrap(21,"*"),
			new DataWrap(31, ""),
			new DataWrap(49, ""),
			new DataWrap(31, ""),
			new DataWrap(9, "")
			
		};
		System.out.println("排序前：\n"+Arrays.toString(data));
		SelectSort(data);
		System.out.println("排序后"+Arrays.toString(data));
			
		
	}


	public static void SelectSort(DataWrap[] data) {
		// TODO Auto-generated method stub
		System.out.println("开始排序：");
		int lengths=data.length;
		//依次进行n-1趟比较，第i趟比较将第i大的值选出放在i位置上
		for(int i=0;i<lengths-1;i++)
		{
			//minIndex永远保留本趟比较中最小的值的索引
			int minIndex=i;
			for(int j=i+1;j<lengths;j++)
			{
				if(data[i].compareTo(data[j])>0){
					minIndex=j;
				}
			}
			//每趟比较最多交换一次
			if(minIndex!=i){
				DataWrap temp=data[i];
				data[i]=data[minIndex];
				data[minIndex]=temp;
				
			}
			System.out.println(Arrays.toString(data));
			
		}
		
	}


}

⑥希尔排序算法

import java.util.Arrays;


public class ShellSort {


	public static void main(String[] args) {
		DataWrap data[]={
				new DataWrap(15, ""),
				new DataWrap(20, ""),
				new DataWrap(-15,""),
				new DataWrap(9, "*")
		};
		System.out.println("排序前：\n"+Arrays.toString(data));
		ShellSort(data);
		System.out.println("排序后：\n"+Arrays.toString(data));




	}


	public static void ShellSort(DataWrap[] data) {
		// TODO Auto-generated method stub
		int lengths=data.length;
		int h=1;
		//按h*3+1得到增量序列的最大值
		while(h<=lengths/3){
			h=h*3+1;
		}
		while(h>0){
			System.out.println("===h的值"+h+"===");
			for(int i=h;i<lengths;i++){
				//当整体后移时，保证data[i]的值不会丢失
				DataWrap temp=data[i];
				//i索引处的值已经比前面所有值都大，表明已经有序，无需插入
				//i-1索引之前的数据已经有序，i-1索引处元素的值就是最大值
				if(data[i].compareTo(data[i-h])<0){
					int j=i-h;
					//整体后移h格
					for(;j>=0 && data[j].compareTo(temp)>0;j-=h){
						data[j+h]=data[j];
					}
					//最后将temp的值插入合适位置
					data[j+h]=temp;
				}
				System.out.println(Arrays.toString(data));
			}
			h=(h-1)/3;
			
		}
	}


}