排序算法:
-
内部排序:指将需要处理的所有的数据都加载到内部存储器中进行排序
-
外部排序:当数据量过大,无法全部加载到内存中,需要借助外部存储器进行排序
-
常见的算法分类:
5.1 冒泡排序
基本思想:通过对待排序从前往后(从下标小的元素开始),依次比较相邻的元素的值,如是发现逆序则交换,使值较大的元素逐渐从前移向后部,像水底的起跑一样。
总结规则:
- 一共进行n-1次大循环(数组中有n个元素)
- 每一次排序的元素在逐渐的减少
- 如果在某次排序的过程中,没有发生一次交换,说明排序已经完成了
public static int[] bubbleSort(int[] arr) {
int temp = 0;
boolean flag = false;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if(arr[j] > arr[j+1]){
flag = true;
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
if(!flag){
break;
}else {
flag = false;
}
}
return arr;
}
5.2 选择排序
选择排序也是属于内部排序,是从要排序的数据中按照指定的规则挑选出某一元素,再依照规则交换位置达到排序的目的。
选择排序的思想:
- 从arr[0]–arr[n-1]中找到最小的数值,然后交换arr[0]和最小值交换位置
- 从arr[1]–arr[n-1]中找到最小的数值,然后交换arr[1]和最小值交换位置
- …
- 直到所有的数据进行交换完成
// 选择排序,选择数组中的最小的元素与arr[0]进行交换,然后继续在剩下的位置寻找次最小值与arr[1]交换,直到将所有的数据排序完成
public static int[] selectSort(int[] arr){
int temp = 0;
int index = 0;
for (int i = 0; i < arr.length-1; i++) {
index = i; // 初始最小值的索引为i
for (int j = i+1; j < arr.length; j++) {
//如果arr[j]小于arr[index],则j为最小值的索引
if(arr[j] < arr[index]){
index = j;
}
}
// 交换最小值和arr[i]的位置
temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
return arr;
}
5.3 插入排序
插入排序属于内部排序法,是对于欲排序的元素以插入的方式寻找该元素的适当位置。
插入排序的思想:把n个待排序的元素看做是一个有序表和无序表,开始时有序表中只含有一个元素,无序表中包含n-1个元素。排序的过程中,每次从无序表中取出第一个元素,把它插入到有序表中的适当位置,使之形成新的有序表。
代码的实现:
/**
* 插入排序,将列表看做一个有序表和一个无序表
* @param arr
* @return
*/
public static int[] insertSort(int[] arr){
int temp = 0;
int index = 0;
for (int i = 1; i < arr.length; i++) {
temp = arr[i];
index = i-1;
// 倒叙判断从i-1到0进行判断,如果出现temp>arr[index],则说明arr[index+1]则为要插入的部分
while (index >= 0 && temp < arr[index]){
arr[index+1] = arr[index]; //依次移动数据
index --;
}
// 在arr[index+1]中插入数据
arr[index+1] = temp;
}
return arr;
}
5.4 希尔排序( 缩小增量排序 )
基本思想: 希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。
安照一定的步长,将一定数量的数据分为一组。设置每组的数据增量为上一次增量的一半,然后将每组的数据量增加,数组减少,直到只剩下一个数组为止。
希尔排序方法:
- 对有序序列插入时采用交换法
- 对有序序列插入时采用移动法
/**
* 希尔交换法
* @param arr
* @return
*/
public static int[] shellSort(int[] arr){
int temp = 0;
int count = 0;
for(int gap = arr.length/2; gap > 0; gap /= 2){
for(int i=gap; i< arr.length; i++){
// 遍历组中的所有数据,gap为步长
for(int j=i-gap; j >= 0; j -= gap){
if(arr[j] > arr[j+gap]){
temp = arr[j];
arr[j] = arr[j+gap];
arr[j+gap] = temp;
}
}
}
}
return arr;
}
// 移动位置(结合插入排序)
public static int[] shellMoveSort(int[] arr){
for(int gap = arr.length/2; gap > 0; gap /= 2){
for(int i=gap; i < arr.length; i++){
int j = i;
int temp = arr[j];
if(arr[j] < arr[j-gap]){
while (j - gap >= 0 && temp < arr[j - gap]){
arr[j] = arr[j-gap];
j -= gap;
}
arr[j] = temp;
}
}
}
return arr;
}
5.5 快速排序
基本思想:通过一次排序将要排序的数据分割成独立的两个部分,其中一部分的所有数据都比另一部分的所有数据都要小,然后按照这种方法对这两个部分数据分布进行快速排序,整个排序部分可以使用递归进行,以此达到整个数据变成有序序列。
思路分析:
- 假设数组为arr,左侧为left,右侧为right,设置选择的初始位置为
- 从左侧开始查找,找到大于等于mid的值为止,从右侧也开始查找,直到找到小于等于mid的值
- 直到找到
l<r
的位置,然后递归进行快速排序。
/**
* 快速排序
*
* @param arr
* @param left
* @param right
* @return
*/
public static int[] quickSort(int[] arr, int left, int right) {
if (left >= right) return null;
// 如果数组中left与right相等或者left大于right,则跳出程序
int l = left;
int r = right;
int mid = arr[(l + r) / 2];
int temp = 0;
while (l < r) {
while (l < r && arr[l] < mid) {
l++;
}
while (r > l && arr[r] > mid) {
r--;
}
if (l >= r) {
break;
}
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
if (arr[l] == mid){
r--;
}
if (arr[r] == mid) {
l++;
}
}
quickSort(arr, left, l - 1);
quickSort(arr, r + 1, right);
return arr;
}
5.6 归并排序
归并排序是利用归并的思想实现的排序方法,该算法采用经典的分治策略(分治法将问题分为一些小的问题然后递归求解,而治阶段则将分的阶段得到的各答案“修补”在一起,即分而治之)
基本方法:
- 首先将数组成分成两个部分,一直拆分直到拆分到每个子数组中只有一个元素
- 然后进行合并相同相邻的拆分部分,按照顺序进行合并,直到合并成完整的数组
- 使用递归方法完成最好,时间复杂度为
O(nlogn)
/**
* 归并排序
* @param arr
* @param left
* @param right
* @return
*/
public static int[] mergeSort(int[] arr, int left, int right){
// 如果left大于right,说明数组中只有1个或者没有数据,则将直接返回空
if(left >= right) return null;
int mid = (left + right)/2;
// 分割
mergeSort(arr, left, mid);
mergeSort(arr, mid+1, right);
int i = left;
int j = mid+1;
int t = 0;
int[] temp = new int[(right - left + 1)];
while (i <= mid && j <= right){
if(arr[i] <= arr[j]){
temp[t] = arr[i];
t ++;
i ++;
}else {
temp[t] = arr[j];
t ++;
j ++;
}
}
// 将剩余的内容填充到temp中
while (i <= mid){
temp[t] = arr[i];
t++;
i++;
}
// 将剩余的right内容填充到temp中
while (j <= right){
temp[t] = arr[j];
t++;
j++;
}
// 将temp数据拷贝到arr中
for(int k=left; k<=right; k++){
arr[k] = temp[k-left];
}
System.out.println("排序后的数据为:" + Arrays.toString(temp));
return arr;
}
5.7 基数排序
- 基数排序属于“分配式排序”,又称桶子法,它是通过键值的各个位的值,将要排序的元素分配到某些“桶”中,达到排序的作用
- 基数排序属于稳定性的排序,基数排序法的是效率高的稳定性排序法
- 基数排序是桶排序的拓展
- 基数排序的实现方法:将整数位按照位数切割成不同的数字,然后按照每个位分别比较。
实现的方法:
- 定义一个二维数组,表示10个桶,每一个桶就是一个一维数组
- 为了防止在放入输的时候数据溢出,则每个一维数组(桶),大小定为arr.length
- 基数排序就是使用空间换时间的经典算法。
/**
* 基数排序
* @param arr
* @return
*/
public static int[] radixSort(int[] arr){
int[][] bubble = new int[10][arr.length]; //设置桶的数量,每个桶最多盛放整个数组
// 寻找数组中最大的数
int max = arr[0];
for(int i=1; i<arr.length; i++){
if(arr[i] > max){
max = arr[i];
}
}
int maxLength = (max + "").length();
// 根据数值中最大数据的位数判定需要多少次循环
for (int i = 0; i < maxLength; i++) {
int[] bubbleLength = new int[10]; // 桶的放的数据的量
// 将数据根据个位、十位、百位依次放入桶中
for (int j = 0; j < arr.length; j++) {
int size = arr[j] / (int)Math.pow(10, i) % 10;
bubble[size][bubbleLength[size]] = arr[j];
bubbleLength[size] ++;
}
//依次将数据取出,并放入到原来的数组中
int index = 0;
for(int j=0; j<bubble.length; j++){
if(bubbleLength[j] > 0){
for(int k=0; k<bubbleLength[j]; k++){
arr[index++] = bubble[j][k];
}
}
}
}
return arr;
}