首先创建一个数据类:
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;
}
}
}