Java基础（18）——常见算法（数组排序）

---

版权声明

• 本文原创作者：清风不渡
• 博客地址：https://blog.csdn.net/WXKKang

---

一、冒泡排序

  冒泡排序是一种对数组中数据元素排序的方法。每一次对数组的遍历都是将较大数交换到后面，这样每次遍历都会将最大值换到最后一位。每次遍历后，排序数组的规模都会减少一个数据元素。
  从数组开始扫描待排序的元素，在扫描过程中依次对相邻元素进行比较，将数值大的元素后移。没经过一趟排序后，数值最大的元素将移到末尾，此时记下该元素的位置，下一趟排序只需要比较到此的位置为止，直到所有的元素都已经有序排列。
  代码如下：

package cn.com;

import java.util.Arrays;

public class Demo {

	public static void main(String[] args) {
		int[] array = {1,4,3,6,8};
		int[] maopao = Demo.maopao(array);
		System.out.println(Arrays.toString(maopao));
	}
	public static int[] maopao(int[] arr){
		int t;
		for (int i = 0; i < arr.length; i++) {
			//循环比较相邻两个元素大小
			for (int j = 0; j < arr.length-i-1; j++) {
				//比价相邻元素大小，小的前移，大的后移
				if(arr[j]>arr[j+1]){
					t=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=t;
				}
			}
		}
		return arr;
	}
}	

二、简单选择排序

  把第一个元素依次和后面的所有元素进行比较;如果后面的数大于第一个数则交换位置。
  第一趟结束后，最小值出现在最前面。
  第二趟结束后，次小值出现在数组的第二个位置。
  以此类推

package cn.com;

import java.util.Arrays;

public class Demo {

	public static void main(String[] args) {
		int[] array = { 1, 4, 3, 6, 8 };
		int[] chooseSort = Demo.chooseSort(array);
		System.out.println(Arrays.toString(chooseSort));
	}

	public static int[] chooseSort(int[] intArray) {
		for (int i = 0; i < intArray.length - 1; i++) {
			for (int j = i + 1; j < intArray.length; j++) {
				if (intArray[j] < intArray[i]) {
					swap(intArray, j, i);
				}
			}
		}
		return intArray;
	}

	public static void swap(int[] intArray, int i, int j) {
		int temp = 0;
		temp = intArray[i];
		intArray[i] = intArray[j];
		intArray[j] = temp;
	}
}

三、插入排序

  将要排序的数组分成两部分，每次从后面的数组部分中取出索引最小的数组元素，插入到前面数组部分的适当位置中。通常在开始排序时，讲数组的第一个元素作为一组，后面的所有元素被当成另一组。代码如下：

package cn.com;

import java.util.Arrays;

public class Demo {

	public static void main(String[] args) {
		int[] array = { 1, 4, 3, 6, 8 };
		int[] charu = Demo.charu(array);
		System.out.println(Arrays.toString(charu));
	}

	public static int[] charu(int[] arr) {
		// 把第一个元素看做一部分，第二个元素看做另一部分
		// 从第二部分中依次取元素插入到第一部分中
		for (int i = 1; i < arr.length; i++) {
			int tmp = arr[i];
			int j = i - 1;
			// 依次和i前面元素比较，寻找合适插入位置、
			while (tmp < arr[j]) {
				arr[j + 1] = arr[j];
				j--;
				if (j == -1) {
					break;
				}
			}
			// 将插入元素插入到合适位置
			arr[j + 1] = tmp;
		}
		return arr;
	}
}

四、快速排序

  将一个大的数组的排序问题，分解成2个小的数组的排序，而每个小的数组的排序又可以继续分解成更小的2个数组，这样一直递归下去，直到数组的大小最大为2，代码如下：

package cn.com;

import java.util.Arrays;

public class Demo {

	public static void main(String[] args) {
		int[] array = { 1, 4, 3, 6, 8 };
		int[] kuaisu = Demo.kuaisu(array);
		System.out.println(Arrays.toString(kuaisu));
	}

	public static int[] kuaisu(int[] arr) {
		return quicksort(arr, 0, arr.length - 1);
	}

	public static int[] quicksort(int[] arr, int left, int right) {
		int t;
		if (left < right) {
			int s = arr[left];
			int i = left;
			int j = right + 1;
			while (true) {
				// 向右找大于s的数的索引
				while (i + 1 < arr.length && arr[++i] < s)
					;
				// 向右找小于s的数的索引
				while (j - 1 > -1 && arr[--j] > s)
					;
				// 如果i>=j，退出循环
				if (i >= j) {
					break;
				} else {
					// 交换i和j位置的位置
					t = arr[i];
					arr[i] = arr[j];
					arr[j] = t;
				}
			}
			arr[left] = arr[j];
			arr[j] = s;
			// 对左边进行递归
			quicksort(arr, left, left - 1);
			// 最右边进行递归
			quicksort(arr, j + 1, right);
		}
		return arr;
	}
}