常用7种排序算法java实现

前面已经把七种排序算法用java实现，也分析了时间复杂度。

这篇是将7种排序方法综合到一个类里，便于快速复习。

可以参考我前面的七篇：点击打开链接

public class SortClass {
	//==========================冒泡排序========================//
	public static  void bubble_sort(int[] arr)
	{
		for(int i = 0; i < arr.length; i ++)
		{
			for(int j = arr.length-2; j>=i; j--)
			{
				if(arr[j] > arr[j+1])
				{
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
	}
	//==========================冒泡排序========================//
	
	//=========================简单选择排序======================//
	public static void Select_Sort(int[] arr)
	{
		int min;  //记录第i次循环的最小值
		for(int i = 0; i < arr.length; i ++)
		{
			min = i;  //假设第i个元素为最小值
			for (int j = i + 1; j < arr.length; j++) 
			{
				if(arr[min] > arr[j])  //如果最小值比i后面的值要大，则更换min
					min = j;
			}
			if(i != min)              //交换第i次循环中，最小值与i的位置
			{
				int temp = arr[i];  
				arr[i] = arr[min];
				arr[min] = temp;
			}
		}
	}
	//=========================简单选择排序======================//
	
	//==========================直接插入排序====================//
	public static void Insert_Sort(int[] arr)
	{
		for(int i = 1; i < arr.length; i ++)
		{
			int j,temp;
			if(arr[i] < arr[i-1])
			{
				temp = arr[i];
				for(j = i-1; j >= 0 && arr[j] > temp; j--)  //arr[j]>temp,将大于temp(arr[i])的部分向右移动一位
				{					//如现在是 {1,3,4,5},temp=arr[i]=2,那么 将arr[j]>2的部分
					arr[j+1] = arr[j];		//也就是 3,4,5向后移动一个位置，这个时候再把 temp也就是arr[i] = 2
				}						//插入3的位置。
				arr[j+1] = temp;  //将temp(arr[i])插入进去
			}
		}
	}
	//==========================直接插入排序====================//
	
	//==========================希尔排序========================//
	public static void Shell_Sort(int[] arr)
	{
		int increment = arr.length;
		int i, j, temp;
		do {
			increment = increment/3 + 1;
			for(i = increment + 1; i < arr.length; i ++)
			{
				if(arr[i] < arr[i-increment])
				{
					temp = arr[i];
					for(j = i - increment; j > 0 && arr[j] > temp; j-=increment) //大于temp(arr[i])的后移
						arr[j+increment] = arr[j];
					arr[j+increment] = temp;         //将arr[i]插入
				}
				
			}
		} while (increment > 1);
	}
	//==========================希尔排序========================//
	
	//===========================堆排序=======================//
	public static void HeapAdjust(int[] arr, int s, int m)  //构建大顶堆
	{
		int temp, j;
		temp = arr[s];
		for(j = 2*s; j < m; j *= 2)   /*沿关键字较大的孩子节点向下筛选*/
		{
			if(j < m && arr[j] < arr[j+1])
				++j;                			 /*j为关键字中较大的记录下标*/
			if(temp >= arr[j])
				break;                  /*如果temp(也就是根节点)大于左右孩子的最大值，就不用交换，退出循环*/
			arr[s] = arr[j];
			s = j;
		}
		arr[s] = temp;
	}
	
	public static void Heap_Sort(int[] arr)
	{
		int i;
		for(i = arr.length/2; i >= 0; i--)  //将arr构建成大顶堆
		{
			HeapAdjust(arr, i, arr.length-1);
		}
		
		for(i = arr.length-1; i >= 0; i--)   //每次循环取出大顶堆的根节点，也就是最大值放在最后一个元素
		{					//将剩下的i-1个元素继续构建成大顶堆
			int temp = arr[0];
			arr[0] = arr[i];
			arr[i] = temp;
			HeapAdjust(arr, 0, i-1);
		}
	}
	//======================堆排序===========================//
	
	//==========================归并排序===================//
	public static void Merge_Sort(int[] arr)
	{
		MSort(arr, arr, 0, arr.length-1);
	}
	public static void MSort(int[] SR, int[] TR1, int s, int t)
	{
		int m;
		int[] TR2 = new int[SR.length];
		if(s == t)
			TR1[s] = SR[s];
		else
		{
			m = (s + t)/2;   //将SR[s..t]平分为SR[s..m] 和 SR[m+1..t]
			MSort(SR, TR2, s, m); //递归将SR[s..m]归并为有序的TR2[s..m]
			MSort(SR, TR2, m+1, t);  //递归将SR[m+1..t]归并为有序TR2[m+1..t]
			Merge(TR2, TR1, s, m, t);  //将TR2[s..m] 和 TR2[m+1..t]归并到TR1[s..t]
		}
	}
	//将有序的SR[i..m] 和 SR[m+1..n] 归并为有序的 TR[i..n]
	public static void Merge(int[] SR, int[] TR, int i, int m, int n)
	{
		int j, k, l;
		for(j = m + 1, k = i; i <= m && j <= n; k++)  //将SR中记录由小到大归并入TR
		{
			if(SR[i] < SR[j])
				TR[k] = SR[i++];
			else
				TR[k] = SR[j++];
		}
		if(i <= m)
		{
			for(l = 0; l <= m - i; l ++)
				TR[k+l] = SR[i+l];    //将剩余的SR[i..m]赋复制到TR
		}
		if(j <= n)
		{
			for(l = 0; l <= n-j; l ++)
				TR[k+l] = SR[j+l];
		}
	}
	//==========================归并排序===========================//
	
	//======================快速排序============================//
	public static void Quick_Sort(int[] arr)
	{
		QSort(arr, 0, arr.length-1);
	}
	public static void QSort(int[] arr, int low, int high)  //对arr中的子序列arr[low..high]作快速排序
	{
		int pivot;
		if(low < high)
		{
			pivot = Partition(arr, low, high);   //将arr一分为二，算出枢轴pivot。小于pivot放在pivot左侧，
												//大于pivot放在pivot右侧，以此枢轴分割序列，再次递归
			QSort(arr, low, pivot-1);      //对小于pivot子序列递归排序
			QSort(arr, pivot+1, high);   //对大于pivot子序列递归排序
		}
	}
	
	//交换arr中子序列的记录，设定一个pivot，是小于枢轴在pivot左侧，
	//大于pivot在右侧，此时pivot在中间，并记录pivot的下标，返回
	public static int Partition(int[] arr, int low, int high)
	{
		int pivotKey, temp;
		pivotKey = arr[low];  //用子序列的第一个记录作为枢轴记录
		while(low < high)   //从数组两端交替向中间扫描
		{
			while(low < high && arr[high] >= pivotKey)
				high--;
			temp = arr[high];      //  将比枢轴记录小
			arr[high] = arr[low];  //  的记录
			arr[low] = temp;      //   交换到低端
			while(low < high && arr[low] <= pivotKey)
				low++;
			temp = arr[low];      //  将比枢轴记录大
			arr[low] = arr[high]; //  的记录
			arr[high] = temp;     //  交换到高端
		}
		return low;       //返回枢轴所在位置，
	}
	//=======================快速排序==========================//
	
	public static void main(String[] args) {
		int[] arr = {0,3,1,2,5,6,8,7,3,33};
		Quick_Sort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
}