|
? ? ? ? 排序是我们平常很容易用到的数据结构，也可以称之为算法，很多场景都能遇见到，比如在查询数据的时候，我们想要数据按照顺序展示，这个时候我们就要用到排序算法。
? ? ? ? 排序算法分为内部排序和外部排序，内部排序的数据都需要加载到内存存储器中排序（一般数据量较少），外部排序的数据量都非常大，内存无法加载完，就需要借助外部存储器，今天我们主要讲的是内部排序。
? ? ? ? 内部排序算法主要分为五大类：插入排序（直接插入排序和希尔排序）、选择排序（简单选择排序和堆排序）、交换排序（冒泡和快排）、归并排序以及基数排序，这篇文章主要讲解直接插入排序、希尔排序、简单选择排序、冒泡排序和快速排序。
? ? ? ? 直接插入排序：插入排序根据字面意思很好理解，就是找到对应的位置将数据插入到数组对应的位置中去；用一个数组解释的话可能比较难get到，那我们就用两个数组解释（但代码实现还是用一个数组实现哈）；假设我们有两个数组，一个数组是我们要排序的数组（我们命名为ordersArrays），一个数组是一个空数组（nullArrays），大小和需要排序的数组大小一致，我们将ordersArrays的第一个数据放入到nullArrays的第一个位置（第一个数据是不需要比较的，所以我们代码实现的时候直接可以跳过第一个数据的比较，从下标1开始），然后我们将ordersArrays的第二个数据与nullArrays中的所有数据进行比较，在nullArrays找到小于ordersArrays的第二个数据位置，然后将数据存入到nullArrays对应的位置即可，如此往复，便可以完成插入排序。好了，文字解释完之后，我们直接上代码：
/**
* 直接插入排序
*/
public class InsertSort {
public int[] sort(int[] arrays) {
for (int i = 1; i < arrays.length; i++) {
//将需要插入的值拿出来
int indexValue = arrays[i];
//保证比较的是数组下标i之前的数据
int index = i - 1;
while (index >= 0 && indexValue < arrays[index]) {
//如果满足条件，就将当前为index的数据后移一个单位，保证数据不丢失
arrays[index + 1] = arrays[index];
index--;
}
//因为是向前面的数据比较，前面的数据都已经排序好了，只要不满足条件
//就将当前的数据放入index + 1的下标数组中
arrays[index + 1] = indexValue;
}
return arrays;
}
}
? ? ? ? 希尔排序： 希尔排序作为选择排序的升级版，就是为了防止极端的数据，比如2000个数据，0在最后一个数据为了防止这种极端的情况发生，我们采用希尔排序来优化希尔排序的原理就是将排序的数组大小除2作为排序的分组通过分组来进行对应的数组数据的交换，这样可以大幅度的减少循环的次数，然希尔排序也有两种方法实现，位移法和交换法。
? ? ? ? 位移法就是直接插入排序中的数据直接替换即可，实现代码如下：
/**
* 希尔排序
*/
public class ShellSort {
/**
* 位移希尔排序
* @param arrays 排序的目标数组
* @return 返回排序后的数组
*/
public int[] moveSort(int[] arrays){
for (int reg = arrays.length / 2; reg > 0; reg /= 2){
for (int i = reg; i < arrays.length; i++){
int index = i;
int temp = arrays[i];
if (arrays[index] < arrays[index -reg]){
while (index - reg >= 0 && temp < arrays[index - reg]){
arrays[index] = arrays[index - reg];
index -= reg;
}
}
}
}
return arrays;
}
}
? ? ? ? 交换法就是我们常用的方法，定义一个辅助变量用来存放值，然后三者进行交换，代码如下：
/**
* 希尔排序
*/
public class ShellSort {
/**
* 交换式希尔排序
* @param arrays 排序的目标数组
* @return 返回排序后的数组
*/
public int[] exchangeSort(int[] arrays){
long beginTime = System.currentTimeMillis();
//第一重循环，目的是求出目标数组将会被分成几组进行比较交换
for (int reg = arrays.length/2; reg > 0; reg /= 2){
//第二重循环，目的是让分出来的组按组去对数据作比较
for (int i = reg; i < arrays.length; i++){
//第三重循环, 目的是让组之间的数据进行交换
for (int j = i - reg; j >= 0; j-= reg){
if (arrays[j] > arrays[j + reg]){
int temp = arrays[j];
arrays[j] = arrays[j + reg];
arrays[j + reg] = temp;
}
}
}
}
return arrays;
}
}
????????简单选择排序：简单选择排序实现原理就是从第一个数组数据跟所有数组的数据进行比较，找到最大或者最小的值，然后将其进行替换，这样依次反复，便可以完成选择排序。代码如下：
import java.util.Arrays;
/**
* 选择排序
*/
public class SelectSort {
public int[] sorts(int[] arrays){
for (int i = 0; i < arrays.length; i++){
//存放每轮查找到的最小的值
int min = arrays[i];
//存放每轮查找到最小值的下标
int minIndex = i;
for (int j = i + 1; j < arrays.length; j++){
//正序排列
// if (min > arrays[j]) {
// min = arrays[j];
// minIndex = j;
// }
//倒序排列
if (min < arrays[j]) {
min = arrays[j];
minIndex = j;
}
}
if (minIndex != i){
arrays[minIndex] = arrays[i];
arrays[i] = min;
}
}
return arrays;
}
}
? ? ? ? 冒泡排序：这个排序方法老生常谈了哈，想水中冒泡一样，将一个一个数据进行比对，然后进行数据交换，可以说就是两个for循环的事情，就不做过多的解释了，代码如下：
/**
* 冒泡排序
*/
import java.util.Arrays;
public class BubbleSort {
public int[] sorts(int[] arrays){
for (int i = 0; i < arrays.length; i++){
for (int j = 0; j < arrays.length; j++){
//正序排列
if (arrays[i] < arrays[j]){
int temp = arrays[j];
arrays[j] = arrays[i];
arrays[i] = temp;
}
//倒序排列
// if (arrays[i] > arrays[j]){
// int temp = arrays[j];
// arrays[j] = arrays[i];
// arrays[i] = temp;
// }
}
}
return arrays;
}
}
? ? ? ? 此外还将冒泡排序优化了一下下，用一个boolean类型的变量作为标志，用其判断数组已经排好序了，这样便可以在循环中便可停止循环，达到提高时间的效果，代码如下：
/**
* 优化,当以此遍历之后数据没有交换,默认数组已经是有序的了
* @param arrays 目标数组
* @return 返回排序数组
*/
public int[] sortsNew(int[] arrays){
for (int i = 0; i < arrays.length; i++){
boolean flag = false;
for (int j = 0; j < arrays.length; j++){
//正序排列
if (arrays[i] < arrays[j]){
flag = true;
int temp = arrays[j];
arrays[j] = arrays[i];
arrays[i] = temp;
}
}
if (!flag){
break;
}
}
return arrays;
}
? ? ? ? 快速排序：快速排序的特点是啥,那就是快。
? ? ? ? 快排的实现原理:先在数组中随便选取一个数据作为基准数(咱一般取中间那个),以此数据作为基准然后对数组进行分割成两个部分的数据,一个部分比基准数据大,一个小然后两个独立的部分数组进行递归比较,比较思路也是先选取基准数据,然后再分割数组,然后再比较,直到数组不能再细分为止。有一个注意点，也是很重要的注意点，在两边值全部交换完毕之后，我们要开始左右递归排序了，在左右递归排序之前，我们一定要比较一下l == r这个条件是否成立，如果成立，则需要r--，l++，如果不处理，则会出现栈满的错误。接下来就是代码实现：
import java.util.Arrays;
/**
* 快速排序
*/
public class QuickSort {
public int[] sort(int[] arrays, int left, int right){
//右边的下标
int r = right;
//左边的下标
int l = left;
//作为基准的值
int middle = arrays[(left + right) / 2];
//临时变量,用来交换
int temp = 0;
while (l < r){
while (arrays[l] < middle){
l++;
}
while (arrays[r] > middle){
r--;
}
if (l >= r){
break;
}
//交换值
temp = arrays[l];
arrays[l] = arrays[r];
arrays[r] = temp;
}
if (r == l){
l++;
r--;
}
//向左递归
if (left < r){
sort(arrays,left,r);
}
//向右递归
if (right > l){
sort(arrays,l,right);
}
return arrays;
}
}
? ? ? ? 以上是我对直接插入排序、希尔排序、简单选择排序、冒泡排序和快速排序五种排序方法的阐述，如有错误，望大佬指正！
|