排序算法以及其他算法

最新推荐文章于 2022-04-26 14:53:52 发布

原创最新推荐文章于 2022-04-26 14:53:52 发布 · 412 阅读

0 ·

CC 4.0 BY-SA版权

JAVA 专栏收录该内容

0 篇文章

订阅专栏

本文介绍了四种常见的排序算法：选择排序、冒泡排序、插入排序和快速排序，并通过Java代码实现展示了每种算法的工作原理。

1. 常见的排序算法：

import java.util.Arrays;

public class Sort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] ary={2,4,1,6,7,9,8};
		System.out.println(
				Arrays.toString(selectionSort(ary)));
		System.out.println(
				Arrays.toString(bubleSort(ary)));
		System.out.println(
				Arrays.toString(insertSort(ary)));
		System.out.println(
				Arrays.toString(quickSort(ary,0,ary.length-1)));

	}
	// 选择排序
	public static int[] selectionSort(int[] ary){
		for(int i=0;i<ary.length-1;i++){
			int min=i;
			for(int j=i+1;j<ary.length-1;j++){
				// 1 种方式
				//if(ary[i]>ary[j]){
				//	int temp=ary[i];
				//	ary[i]=ary[j];
				//	ary[j]=temp;
				//}
				// 2 种方式
				if (ary[min] > ary[j])
				{
					min = j;
				}
			}
			// 2 种方式
			if(min!=i){
				int temp = ary[i];
				ary[i]=ary[min];
				ary[min]=temp;
			}
			
		}
		return ary;
	}
	// 冒泡排序
	public static int[] bubleSort(int[] ary){
		for(int i=0;i<ary.length-1;i++)
			for(int j=0;j+1<ary.length-i;j++){
				if(ary[j]>ary[j+1]){
					int temp=ary[j];
					ary[j]=ary[j+1];
					ary[j+1]=temp;
				}
			}
		return ary;
	}
	// 插入排序
	public static int[] insertSort(int[] ary){
		int j;
		for(int i=1;i<ary.length;i++){
			int temp=ary[i];
			for(j=i-1;j>=0&&temp<ary[j];j--){
				//if(temp<ary[j])
					ary[j+1]=ary[j];
				//else 
				//	break;
			}
			ary[j+1]=temp;
		}
		return ary;
	}
	//快速排序算法的使用
	public static int[] quickSort(int arr[],int left,int right)
	{
		//1.选择中间元素作为基准值,存储起来
		int p = (left+right)/2;
		int pivot = arr[p];
		//2.分别使用左边元素和右边元素与基准值进行比较，直到左边和右边的下标重合
		int i = 0,j = 0;
		for(i = left,j = right; i < j;)
		{
			//2.1 使用左边元素和基准值比较，如果左边有元素并且比基准值小则比较下一个元素
			while(i < p && arr[i] < pivot)
			{
				i++;
			}
			//2.2 如果左边元素比基准值大时
			if(i < p)
			{
				arr[p] = arr[i];
				p = i;
			}
			//2.3 如果右边的元素存在并且比基准值大时,则比较下一个
			while(p < j && arr[j] >= pivot)
			{
				j--;
			}
			//2.4 如果右边的元素比基准值小
			if(p < j)
			{
				arr[p] = arr[j];
				p = j;
			}
		}
		//3.左边元素下标和右边元素下标重合时
		arr[p] = pivot;
		//4.分别对基准值左边和右边的元素进行递归
		if(p - left > 1)
		{
			quickSort(arr,left,p-1);
		}
		if(right - p > 1)
		{
			quickSort(arr,p+1,right);
		}
		return arr;
	}
}