java讲讲几种常见的排序算法（二）

java讲讲几种常见的排序算法（二）

目录

• java讲讲几种常见的排序算法(一)
• java讲讲几种常见的排序算法(二)

堆排序

思路：构建一个小顶堆，小顶堆就是棵二叉树，他的左右孩子均大于他的根节点（大顶堆反之）。

构建完一个小顶堆后，开始排序。 将最后一个节点和第一个节点交换位置（根节点是最小的，最小的顶点放到了后面），交换后进行调整，保持小顶堆（次小的顶点到了根节点）。

依次执行下去，这样每一次交换将最小的顶点的放到了最后，所以最后数组会从大到小排列。

public static void heapSort(int array[])
	{
		int j=array.length;
		//构建堆
		for (int i = j/2-1; i >=0; i--) {
			f(i,j,array);
		}
		//堆排序，从后面的节点开始更第一个节点交换位置，然后进行调整，这样数组将从大到小排列
		for (int i = j-1; i>=0; i--) {
//			System.out.println(array[0]);
			swap(array,i,0);
			f(0,i,array);
		}
	}
	public static void f(int low,int high,int array[])
	{
		int i=low;
		int j=2*i+1;
		int temp=array[i];
		while(j<high)
		{
			//左节点和有节点哪个大
			if(j<high-1&&array[j]>array[j+1])
				j++;
			//如果大于根节点，进行上浮，将该节点上浮，对下面的子树再进行调整
			if(array[j]<temp)
			{
				array[i]=array[j];
				i=j;
				j=2*i+1;
			}
			else
				break;
		}
		array[i]=temp;
	}

桶排序

思路：构建十个桶，0-9十个桶，每个桶存放一个链表。

比如 26 16 3，先从个位数开始，分别是 6 6 3，所以第6个桶的链表存放26 16，第3个桶的链表存放3，然后按顺序从0-9个桶读取，读取完数组顺序是3 26 16。

接着再从十位开始，分别是0 2 1，所以同样的操作放入桶里，这样的话第0个桶存放3，第二个桶存放26，第一个桶存放16，然后按顺序从0-9个桶读取，最后按顺序排列3 16 26。因为十位已经是最大位，所以停止排序。

//创建10个桶，每个桶存一个链表
public static List createBucket()
	{
		List <LinkedList<Integer>>bucketList=new ArrayList<LinkedList<Integer>>(10);
		for (int i = 0; i < 10; i++) {
			bucketList.add(new LinkedList<Integer>());
		}
		return bucketList;
	}
	public static void bucketSort(int array[],int base,List<LinkedList<Integer>> bucketList)
	{

		//100以内的数，超过100不用再就千分位的数
if(base==1000)
			return;
		for (int i = 0; i < array.length; i++) {
			LinkedList<Integer> bucket=bucketList.get((array[i]/base)%10);
			bucket.add(array[i]);
		}
		int index=0;
		for (int i = 0; i < bucketList.size(); i++) {
				LinkedList<Integer> bucket=bucketList.get(i);
				if(bucket.isEmpty())
					continue;
				else
				{
					while(!bucket.isEmpty())
					{
						array[index]=bucket.poll();
						index++;
					}
				}
		}
		bucketSort(array,base*10,bucketList);

	}

归并排序

思路：将一个数组分成两部分（A,B）。

A实现左边有序，再实现右边有序，然后进行合并，最后实现A这一个大部分实现有序。

然后B同样进行以上同样的操作，最后B这一大部分实现有序，最后，AB合并，实现整体有序。

同样，在实现A的有序也是自底向上进行合并的。

public static void mergeSort(int array[],int first,int end,int temp[])
	{
		int mid=(first+end)/2;
		if(first<end)
		{
			//左边有序
			mergeSort(array,first,mid,temp);
			//右边有序
			mergeSort(array,mid+1,end,temp);
			//进行合并
			merge(array,first,mid,end,temp);
		}
	}
	public static void merge(int array[],int first,int mid,int end,int temp[])
	{
		int index1=first,index2=mid+1;
		int k=first;
		for (int i = first; i < end+1; i++) {
			temp[i]=array[i];
		}
		while(true)
		{

			if(index1==mid+1&&index2==end+1)
			{
				break;
			}
			else
			{
				if(index1==mid+1)
				{
					for(int n=index2;n<=end;n++)
					{
						array[k++]=temp[n];
					}
					break;
				}
				else if(index2==end+1)
				{
					for(int n=index1;n<=mid;n++)
					{
						array[k++]=temp[n];
					}
					break;
				}
				else
				{

					if(temp[index1]<temp[index2])
					{
						array[k++]=temp[index1++];
					}
					else
					{
						array[k++]=temp[index2++];
					}

				}
			}

		}
	}

后面会继续更新几种常见排序算法。

我觉得分享是一种精神，分享是我的乐趣所在，不是说我觉得我讲得一定是对的，我讲得可能很多是不对的，但是我希望我讲的东西是我人生的体验和思考，是给很多人反思，也许给你一秒钟、半秒钟，哪怕说一句话有点道理，引发自己内心的感触，这就是我最大的价值。（这是我喜欢的一句话，也是我写博客的初衷）