java实现排序九大算法

直接插入排序

public class AAddB {
    public static void main(String[] args) {
        //
        int a[]={1,2,34,5,6,74,3,2,4523,42,24,4,555,534};
        for (int i=1;i<a.length;i++){
            //排序
            if(a[i]<a[i-1]){//a[i]被插入数据 ，0~i-1默认是已经排好的 数据
                //开始从后往前遍历
                int t=a[i];//保存a[i]的值
                for(int j=i-1;j>=0&&t<a[j];j--){//比较并进行 以移位操作
                    a[j+1]=a[j];
                    a[j]=t;
                }
            }
        }
        for (int x:a){      
            System.out.println(x);
        }
    }
}

折半插入算法

public class AAddB {
		public static void main(String[] args) {
//折半查找
			int[] test ={1,44,2,54,3};
			int high=0;//赋初值  定义 相关 需要的 变量 ,这些全部代表的 是 位置 
			int m=0;
			int low=0;
			for (int i=1;i<test.length;i++){//表示前i-1的位置为已经排好序的数组，数组中 第i号 为带插入数据
				low =0;
				high=i-1;
				int tmp=test[i];
//通过1while 语句 进行 循环遍历确定好位置
				while(low<=high){
					m=(low+high)/2;
					if(tmp>test[m]){
//大于中间值选择 后半部分数据  抛弃比较的 中间数
						low=m+1;
					}else {
//小于中间值选择 前半部分数据  抛弃比较的 中间数
						high=m-1;
					}
				}
//进行移位操作,此时移位 是从 low+1~i

				for(int j=i;j>low;j--){
					test[j]=test[j-1];
				}
				test[low]=tmp;//插入元素 我已开始 没有记录缓存值所以 每一次 的 test[low]赋值都错了因为上一不已经移位了
			}
			for (int x : test){
				System.out.println(x);
			}
		}

	}

希尔算法(巨烦，一开始写的时候很怀疑自己写的有问题)

public class AAddB {
	public static void main(String[] args) {
//使用希尔算法---保持相对 的
		int arr[]={13,56,2,7,2,4,6,7,8,2,1};

		int d =arr.length/2;//初始化步长
//根据定义 的 步长 进行 分组 
		while(d!=0){//每一次的 排序 之后 就进行做小一半的 步长
			List list=new ArrayList();//用于缓存被选出的 数据组成数组
			for(int m=0;m<d;m++){
				list.clear();
				for(int n=m;n<arr.length;n+=d){
					list.add(arr[n]);
				}
//存放完毕装换成 数组 并传
//装换成数组,然后进行排序
				int[] tmp=new int[list.size()];
				for (int i=0;i<list.size();i++){
					tmp[i]=(int) list.get(i);
				}
//进行排序
				tmp=paixu(tmp);
//重新 为相对位置 的数据进行 赋值 
				for(int x=m,y=0;x<arr.length;x+=d,y++){
//重新赋值
					arr[x]=tmp[y];
				}
			}
			d=d/2;
		}
		System.out.println("最后排序结果:");
		for (int x:arr){
			System.out.print(x+" ");
		}
		System.out.println('\n');
	}

	public static int[] paixu(int arr[]){

//每一次对传进来 的 数组进行排序--使用 直接 插入 排序 
		for (int i=1;i<arr.length;i++){
			int tmp=arr[i];//临时缓存数据  
			if(arr[i]<arr[i-1]){//更小进行排序
				for(int j=i-1;j>=0&&tmp<arr[j];j--){//移位比较
					arr[j+1]=arr[j];
					arr[j]=tmp;
				}
			}
		}
/*for(int t :arr){
System.out.print(t+" ");
}*/
		/* System.out.print('\n');*/

		for (int x:arr){
			System.out.print(x+" ");
		}
		System.out.println('\n');
		return arr;
	}
}

冒泡排序（没什么可以说的 ，这个 算法应该是 所有编程语言学习练手的题目了，最好实现的是python - 。-）

public class AAddB {
	public static void main(String[] args) {
//冒泡排序
		int arr[]={1,3,56,6,3,2,2,1,5,5};
//不停地 进行 冒泡 排序直到所有的 元素 都不需要进行比较为止 没遍历一次就减少对最后一个元素 的 遍历,所以这里我们选择 从头向后遍历
		for(int i=arr.length-1;i>=0;i--){
			for(int j=0;j<i;j++){//进行两两对比并交换位置,由i确定次数,i 确定最后一位 arr.lenth-2
				if(arr[j+1]<arr[j]){
					int tmp=arr[j+1];//缓存j+1元素
					arr[j+1]=arr[j];
					arr[j]=tmp;
				}
			}
		}
		for (int x:arr){
			System.out.print(x+ " ");
		}
		System.out.print('\n');
	}

}

快速排序(看到位博主的 填坑法，勉强写出来了)

public class AAddB {
	public static void main(String[] args) {
		int[] arr={44,1,3,4,5633,47,3,3,45,6,7};//
//分支法地柜调用 
		int i=0;
		int h=arr.length-1;
		int key=i;
		sort(arr, i, h);
		for (int x:arr){
			System.out.print(x+" ");

		}
	}

	public static int paixu(int[] arr,int x,int y){//这个x,y代表了 这个 数组 的 低和高位坐标
//
		int i=x;
		int j=y;
		int key=arr[i];//设定初期flag比较值
		while(i<j){//其实最后 的退出 结果 一定是 i==j 你想 i本来比j小  ，入如果不停递增 一个 不听递减，总有一刻会产生 i==j
//开始从后往前遍历找 比flag小的 数据
			while(i<j){

				if(arr[j]<key){
//交换位置
					arr[i]=arr[j];//挖出一个坑 arr[j];待填补
					i++;//这里++是后面的比较是没有必要在从这个 i开始了 ，所以 ++其实 也可以不用 
					break;//成功之后推出 一次的操作
				}
				j--;
			}
//开始从前往后遍历找 比flag大的 数据
			while(i<j){
				if(arr[i]>key){
//交换位置
					arr[j]=arr[i];//挖出一个坑 arr[i] 去填补上次 的 arr[j]的那个坑，完美啊！！！！
					j--;//这个是一样的意思
					break;//成功之后推出 一次的操作
				}
				i++;
			}
//一次操作完成 下一次操作 开始 时i和j已经从下一位 开始进行 
		}
//遍历完成 填补最后留下的 那个 坑此时i==j原因上面已经说明白了
		arr[i]=key;
		return i;//返回此时 的 标示的位置
	}
	public static void sort(int[] arr,int l,int m){
		if(l<m){
			int key=paixu(arr,l,m);
			sort(arr,l,key-1);
			sort(arr,key+1,m);
		}
	}
}

简单选择排序(初次看的时候有点莫名其妙，这个 不就是 按顺序查找到对应的 为对应数值吗 ，，什么 情况 啊–但是写起来 超级简单 科普一下 说是 冒泡每一对都交换太麻烦了 这个 算法 只有找到合适的 位置 对应的 值才会进交换，少了交换步骤)

http://www.cnblogs.com/jingmoxukong/p/4303289.html

public class AAddB {
	public static void main(String[] args) {
//就是一次 重新对排位对应的 值进行 重新 赋值 
		int [] arr={1,2,4,5,4,3,2,3,56,3,22,4};
		for (int i=0;i<arr.length;i++){//从1位进行开始比较
			getMinValue(arr,i);
		}
		for (int x:arr){
			System.out.print(x+" ");
		}
	}

	//从一个 数组中获取 最小值 
	public static void getMinValue(int[] arr,int i){//代表容器数组 ，以及开始 的数组 的下标 
		int postion=i;//用于记录 最后最小位置 的 下标
		int tmp=arr[i];
		for (int j=i;j<arr.length;j++){//开始遍历查找 最小 数据 O(n)
			if(tmp>arr[j]){
				tmp = arr[j];
				postion=j;
			}
		}
//结束进行位置交换
		if(postion!=i){//表示没有交换任何 的位置 ---所以不需要 任何 的 位置 交换 
			arr[postion]=arr[i];
			arr[i]=tmp;//交换完成数据
		}
	}
}

归并排序：所谓归并是指将若干个已排好序的部分合并成一个有序的部分。 其实很好 理解的—那个 就是 两边 拍好之后 在进行 合并这排序一次 就是先分割在合并 -）

int adjustheap(int *p,int hn,int i){
    int item;
    int lchild=2*i+1;
    int rchild=2*i+2;
    int largest=i;
    while(lchild
        if(lchildp[largest])   //左孩子存在且大于父亲
            largest=lchild;
        if(rchildp[largest])   //右孩子存在且大于父亲
            largest=rchild;
 
        if(largest!=i){     //若父节点不是三者中最大的
            item=p[i];       //将三者中最大的与父节点交换
            p[i]=p[largest];
            p[largest]=item;
 
            i=largest;       //最大的节点与父节点交换后可能导致以其为父节点的左右孩子比其大。则以其为父节点递归调整
            lchild=2*i+1;
            rchild=2*i+2;
        }
        else{
            break;
        }
    }
   return 0;
}
 
//建堆其实就是对无序序列数组对应的完全二叉树的所有节点进行调整形成一个大/小顶堆
 
int buildheap(int *p,int hn){
     int i,begin;
     begin=hn/2-1;         //从最后一个节点的父节点开始
     for(i=begin;i>=0;i--){
        adjustheap(p,hn,i);
     }
     return 0;
}
 
int main()
{
    int n,i,j,hn,item;
    int *p;
    scanf("%d",&n);
    p=(int *)malloc(n*sizeof(int));
    for(i=0; i
        scanf("%d",&p[i]);
 
    hn=n;
    buildheap(p,hn);  //将无序序列建成堆并调整所有节点使树成为大/小顶堆
 
    while(hn>1){
 
        item=p[0];       //将堆顶与最底一个节点交换
        p[0]=p[hn-1];
        p[hn-1]=item;
        hn--;
 
        adjustheap(p,hn,0);  //将重新形成的无序序列的根节点与左右孩子进行调整
    }                    //不用重新调整所有节点，因为最大/小值必定为根节点的左/右孩子
    for(j=0;j
           printf("%d ",p[j]);
        printf("\n");
    return 0;
}

*
 
//递归算法
#include
#include
#include
 
int meger(int *p,int low,int high){
 
        int mid=(low+high)/2;
        int left1=low;
        int right1=mid;
        int left2=mid+1;
        int right2=high;
        int *item,i,k;
        item=(int *)malloc((high-low+1)*sizeof(int));//暂存合并后的序列
        k=0;
        while(left1<=right1&&left2<=right2)
        {
            if(p[left1]
                item[k++]=p[left1++];
            else
                item[k++]=p[left2++];
        }
        while(left1<=right1)
            item[k++]=p[left1++];
        while(left2<=right2)
            item[k++]=p[left2++];
        for(i=0; i
            p[low+i]=item[i];   //对有序的俩段序列进行合并
}
 
int meger_sort(int *p,int low,int high)
{
    int mid;
    if(low
    {
        mid=(low+high)/2;   //递归不断分段，至每段长度都为一时返回
        meger_sort(p,low,mid);
        meger_sort(p,mid+1,high);
        meger(p,low,high);
    }
}
 
int main()
{
    int n,i;
    int *p;
    scanf("%d",&n);
    p=(int *)malloc(n*sizeof(int));
    for(i=0; i
        scanf("%d",&p[i]);
    meger_sort(p,0,n-1);
   for(i=0; i
            printf("%d ",p[i]);
    printf("\n");
    return 0;
}
 
 
//非递归调用
 
#include
#include
#include
 
int _sort(int *p,int n,int start1,int start2,int num){
    int *item;
    item=(int *)malloc(n*sizeof(int));
    int i=0,j=0,k=0;
    while(i
        if(p[start1+i]
            item[k++]=p[start1+i];
            i++;
        }
        else if(p[start1+i]==p[start2+i]){
             item[k++]=p[start1+i];
             i++;
             j++;
        }
        else{
            item[k++]=p[start2+j];
            j++;
        }
    }
    while(i
        item[k++]=p[start1+i];
        i++;
    }
    while(j
        item[k++]=p[start2+j];
        j++;
    }
    for(i=start1,j=0;i
        p[i]=item[j];
}
 
 
int meger_sort(int *p,int n){
    int num=1,i,j;
    while(num
        for(i=0;i
            int start=2*num*i;
            _sort(p,n,start,start+num,num);
        }
    num*=2;
    }
    return 0;
}
 
int main()
{
    int n,i;
    int *p;
    scanf("%d",&n);
    p=(int *)malloc(n*sizeof(int));
    for(i=0; i
        scanf("%d",&p[i]);
 
    meger_sort(p,n);
 
    for(i=0;i
        printf("%d ",p[i]);
    printf("\n");
    return 0;
}

基数排序

public class AAddB {
	public static void main(String[] args) {
//位数不够 自动 补零
		int[] arr ={12,3,5};
		int tmp=0;
//找出 位数 最大的 值 
		for (int i=0;i<arr.length;i++){
			if(String.valueOf(arr[i]).length()>tmp){
				tmp=String.valueOf(arr[i]).length();
			}
		}
		for (int j=0;j<tmp;j++){
			arr=sort(j,arr);
		}

		for (int x:arr){
			System.out.println(x);
		}
	}

	public static int[] sort(int i,int[] arr){//i从后往前查找 
		int[] tmp=new int[arr.length];

//使用10 个桶
		List list0=new ArrayList();
		List list1=new ArrayList();
		List list2=new ArrayList();
		List list3=new ArrayList();
		List list4=new ArrayList();
		List list5=new ArrayList();
		List list6=new ArrayList();
		List list7=new ArrayList();
		List list8=new ArrayList();
		List list9=new ArrayList();

//进行其实 就是 按位填充 
		for (int j=0;j<arr.length;j++){
			char[]  tmp_arr=String.valueOf(arr[j]).toCharArray();

//对应的 位数 进行 添加 
			if(tmp_arr.length<(i+1)){
				list0.add(arr[j]);
				; continue;
			}
			int postion= Integer.valueOf(String .valueOf(tmp_arr[tmp_arr.length-i-1]));
			switch (postion) {
				case 0:
					list0.add(arr[j]);
					break;
				case 1:
					list1.add(arr[j]);
					break;
				case 2:
					list2.add(arr[j]);
					break;
				case 3:
					list3.add(arr[j]);
					break;
				case 4:
					list4.add(arr[j]);
					break;
				case 5:
					list5.add(arr[j]);
					break;
				case 6:
					list6.add(arr[j]);
					break;
				case 7:
					list7.add(arr[j]);
					break;
				case 8:
					list8.add(arr[j]);
					break;
				case 9:
					list9.add(arr[j]);
					break;
				default:
					break;
			}
		}
		list0.addAll(list1);
		list0.addAll(list2);
		list0.addAll(list3);
		list0.addAll(list4);
		list0.addAll(list5);
		list0.addAll(list6);
		list0.addAll(list7);
		list0.addAll(list8);
		list0.addAll(list9);
		for(int m=0;m<arr.length;m++){
			tmp[m]=(int) list0.get(m);
		}
		return tmp;//返回新的 数组 然后进行 排序
	}
}