java排序算法

一、排序算法种类

 

1、经常使用的排序算法：

(1)、选择排序

(2)、冒泡排序

(3)、快速排序

(4)、插入排序

 

需要了解的算法：

(5)、堆排序

(6)、归并排序

(7)、计数排序

(8)、桶排序

(9)、基数排序

 

二、常用算法的原理和实现

1、选择排序

排序原理：

从前往后每一个数和后面的数值进行比较。

 

算法实现：

import java.util.Arrays;

public class XuanzepaixuTest {

	/**
	 * {4,23,5,1,21,34}
	 * 使用选择排序进行操作然后输出排序前的内容和排序后的内容
	 * 什么是选择排序：从前往后每一个数和前后面的数值进行比较
	 * 5,4,3,2,1
	 * -----
	 * ----
	 * ---
	 * --
	 * -
	 * 
	 * 
	 */
//	定义一个数组排序的功能，参数传入一个int型数组
	public static void f(int[] arr){
		//从0开始，最后一个位置不用排序
		for(int i=0;i<arr.length-1;i++){
			//内嵌for循环说明“选择排序”的原理，和后面的元素一一比较
			for(int j=i+1;j<arr.length;j++){
				//判断，如果前面的数值小于后面的数值，就换位
				if(arr[i]<arr[j]){
					//设置一个中间变量temp转换
					int temp=arr[i];
					arr[i]=arr[j];
					arr[j]=temp;
				}
			}
		}
	}
	//遍历函数
	public static void printout(int[] arr){
		System.out.print("[");	
		for(int x=0;x<arr.length;x++){	//使用for循环遍历进行输出数组中的内容，这样很简单的
			if(x==arr.length-1){
				System.out.print(arr[x]);
			}
			else{
				System.out.print(arr[x]+",");
			}
		}
		System.out.print("]");
		System.out.println();//换行操作
		
	}
	//主函数调用这些功能
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("原数组：");
		int[] arr={4,23,5,1,21,34};
		printout(arr);
		System.out.println("排序之后：");
		f(arr);
		printout(arr);
	}
}

2、冒泡排序

排序原理：

从前往后相邻的元素进行比较

 

算法实现：

import java.util.Arrays;


public class Maopaopaixu {

	/**
	 * 冒泡排序的思想：比较相邻的两个元素的大小
	 * {3,1,7,0,5,8,12}
	 * 一次遍历即可
	 * {3,2,1}
	 * {2,3,1}
	 * {2,1,3}
	 * {1,2,3}
	 */
	public static void maopao(int[] arr){
		//从0开始遍历，到数组的到数第二个位置
		for(int i=0;i<arr.length-1;i++){
			//从0开始，跟后面相邻的元素进行比较，
			for(int j=0;j<arr.length-i-1;j++){
				//如果前面的数值大于后面的数值，就换位
				if(arr[j]>arr[j+1]){
					//定义中间变量
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
	}
	//遍历函数
	public static void printout(int[] arr){
		System.out.print("[");	
		for(int x=0;x<arr.length;x++){	//使用for循环遍历进行输出数组中的内容，这样很简单的
			if(x==arr.length-1){
				System.out.print(arr[x]);
			}
			else{
				System.out.print(arr[x]+",");
			}
		}
		System.out.print("]");
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr=new int[]{3,1,7,0,5,8,12,6};
		System.out.println("原数组是：");
		printout(arr);
		System.out.println();
		System.out.println("经过冒泡排序的数组是：");
		maopao(arr);
		printout(arr);
	}

}

3、快速排序

排序原理：

快速排序是对“冒泡排序”的一种改良排序算法。通过第一趟排列将需要排序的指定数组元素切割成两个独立的数组，其中第一部分数组中的元素比第二部分数组中的元素都要小，然后按照此方法将两个数组中的元素进行快速排序（运用到了“递归调用”），直到最后整个数组中的元素都成为有序的。

 

快速排序的实现：

要求：将数组int[] arr={12,7,5,23,8,25,24}中的元素使用“快速排序”的算法序列化。
分析：将数组简写成a[]，那么上面的数组可以表示成a[0]到a[6]。选取第一个元素作为参考数据，然后进行排序，所有比它小的元素都放在前面，所有比它大的元素都放在后面。

 

步骤：

1、定义两个变量left和right，left的值是0，right的值是6。
2、这里将第一个元素作为被比较的对象pivot=a[0]。
3、从right开始向前right--比较，找到第一个小于pivot的值后进行交换。
4、从left开始向后left++比较，找到第一个大于pivot的值后进行交换。
5、重复上述两个步骤，直到left==right
6、定义一个“快速排序”函数sort(int[] arr,int left,int right)用来给数组进行一趟排序操作。
7、定义一个“递归”函数recursion(int[] arr,int left,int right)用来调用自己 。

代码实现：

package com.itheima;



public class Test4 {

	// 定义“递归”函数recursion，函数中的参数分别是int类型的数组，数组中的最左下标，最右下标
	public static void recursion(int[] arr, int left, int right) {

		// 定义枢轴pivot
		int pivot;

		// 如果下标left小于right成立，进入判断语句
		if (left < right) {

			// 将sort方法中返回的下标left赋值给枢轴pivot
			pivot = sort(arr, left, right);

			// 递归调用自身函数，从最右面向前比较
			recursion(arr, left, pivot - 1);

			// 递归调用自身函数，从最前面向后比较
			recursion(arr, pivot + 1, right);
		}
	}

	// 定义“快速排序”函数sort，参数分别是需要排序的数组、数组中的最左下标，最右下标
	public static int sort(int[] arr, int left, int right) {

		// 这里定义枢轴是数组的第一个元素，也就是arr[0]位置上的元素
		int pivot = arr[left];

		// 定义一个while循环，如果左面的下标小于右面的下标，那么返回true，循环体执行
		while (left < right) {

			/*
			 * 判断语句，如果左面的下标小于右面的下标，并且数组中右面的元素大于枢轴， 
			 * 那么右面的下标执行自减1操作
			 */
			if (left < right && arr[right] >= pivot) {
				--right;
			}

			// 将先开始定义在left下标上的枢轴pivot换到right下标上去
			arr[left] = arr[right];

			/*
			 * 判断语句，如果左面的额下标小于右面的下标，并且数组中左面的元素小于等于
			 * 枢轴，那么左面的下标执行自增1操作
			 */
			if (left < right && arr[left] <= pivot) {
				++left;
			}

			// 将已经换到right下标上的枢轴pivot换到left下标上去
			arr[right] = arr[left];
		}

		// 直到数组中下标left上的元素等于枢轴pivot，返回下标left的值
		arr[left] = pivot;
		return left;
	}

	// 定义一个遍历函数，用来输出数组中的元素
	public static void traverse(int[] arr) {

		// 为了便于观看，在输出的数组元素之前加上“[”符号
		System.out.print("[");

		// 进入for循环，对传入到该函数的数组进行遍历
		for (int i = 0; i < arr.length; i++) {
			
			//判断，如果到了数组最后一个下标，就不输出逗号，只输出数组元素
			if(i==arr.length-1){
				System.out.print(arr[i]);
			}
			//如果还没有遍历到数组最后，就输出数组元素和逗号
			else{
				System.out.print(arr[i]+",");
			}
		}

		// 同上，为了便于观看，加上符号“]”
		System.out.println("]");
	}

	// 主函数
	public static void main(String[] args) {

		// 定义一个需要被排序的数组arr
		int[] arr = { 12, 7, 6, 23, 8, 24, 25 };

		// 打印一行内容
		System.out.println("原数组是：");

		// 调用遍历函数，将原数组内容打印一边
		traverse(arr);

		// 打印一行内容
		System.out.println("\r\n" + "快速排序之后的数组是：");

		// 调用“递归”函数，将需要进行“快速排序”的数组传入作为参数
		recursion(arr, 0, arr.length - 1);

		// 调用遍历函数，遍历快速排序之后的数组arr
		traverse(arr);
	}
}

4、排序效率

这三种排序中，”快速排序“的效率最高。