排序算法包括：冒泡排序、简单选择排序、插入排序、希尔排序、归并排序、快速排序、基数排序、计数排序、桶排序。这是学习记录一下，参考博客https://www.cnblogs.com/10158wsj/p/6782124.html?utm_source=tuicool&utm_medium=referral
/**
* 冒泡排序(升序)
* 比较两个相邻的元素，将值大的元素交换至右端
* @param arr 要排序的数组
*/
private static void bubbleRightSort(int[] arr) {
int arrLength = arr.length;
for(int i = 0; i<arrLength; i++) {
for(int j = 0; j<arrLength-i-1; j++) {
if(arr[j]>arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
/**
* 冒泡排序(降序)
* 比较两个相邻的元素，将值大的元素交换至左端
* @param arr 要排序的数组
*/
private static void bubbleLeftSort(int[] arr) {
int arrLength = arr.length;
for(int i = 0; i<arrLength; i++) {
for(int j = arrLength-1; j>i; j--) {
if(arr[j]>arr[j-1]) {
int temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
}
}
}
}
/**
* 简单选择排序
* 选择排序和冒泡排序区别
* 1.冒泡排序是比较相邻两个位置的两个数，而选择排序是按顺序比较，找最大值或最小值
* 2.冒泡排序每轮比较后，位置不对都需要交换位置，而选择排序每一轮比较只需交换一次位置
* 3.冒泡排序是通过数找位置，选择排序是给定位置去找数
* 4.交换过程是不一样的，查找过程是一样的
* @param arr 要排序的数组
*/
private static void selectRightSort(int[] arr) {
int arrLength = arr.length;
for(int i = 0; i<arrLength; i++) {
int minIndex = i;
for(int j = i; j<arrLength; j++) {
if(arr[j]<arr[minIndex]) {
minIndex = j;
}
}
int temp = arr[minIndex];
arr[minIndex] = arr[i];
arr[i] = temp;
}
}
/**
* 简单选择排序(降序)
* @param arr
*/
private static void selectLeftSort(int[] arr) {
int arrLength = arr.length;
for(int i = 0; i<arrLength; i++) {
int maxIndex = i;
for(int j = i; j<arrLength; j++) {
if(arr[j]>arr[maxIndex]) {
maxIndex = j;
}
}
int temp = arr[maxIndex];
arr[maxIndex] = arr[i];
arr[i] = temp;
}
}
/**
* 插入排序(升序)
* 通过构建有序序列，对未排序的数据，在已排序的序列中从后向前扫描，找到相应位置并插入。
* 插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间
* @param arr 要排序的数组
*/
private static void insertionRightSort(int[] arr) {
int arrLength = arr.length;
int current;
for(int i = 0; i<arrLength-1; i++) {
current = arr[i+1];
int preIndex = i;
while (preIndex >= 0 && current <arr[preIndex]) {
arr[preIndex+1] = arr[preIndex];
preIndex--;
}
arr[preIndex+1] = current;
}
}
/**
* 插入排序(降序)
* @param arr 要排序的数组
*/
private static void insertionLeftSort(int[] arr) {
int arrLength = arr.length;
int current;
for(int i = 0; i<arrLength-1; i++) {
current = arr[i+1];
int preIndex = i;
while (preIndex >= 0 && current >arr[preIndex]) {
arr[preIndex+1] = arr[preIndex];
preIndex--;
}
arr[preIndex+1] = current;
}
}
/**
* 希尔排序(也叫缩小增量排序)(升序)
* 希尔排序也是一种插入排序，它是简单插入排序经过改进的一个更高效的版本，也称缩小增量排序。
* 它与插入排序不同之处在于，它会优先比较距离较远的元素。
* @param arr
*/
private static void shellRightSort(int[] arr) {
int arrLength = arr.length;
int temp,gap = arrLength/2;
while(gap>0) {
for(int i = gap; i<arrLength; i++) {
temp = arr[i];
int preIndex = i - gap;
while(preIndex >= 0 && arr[preIndex] > temp){
arr[preIndex + gap] = arr[preIndex];
preIndex -= gap;
}
arr[preIndex + gap] = temp;
}
gap /= 2;
}
}
/**
* 希尔排序(降序)
* @param arr
*/
private static void shellLeftSort(int[] arr) {
int arrLength = arr.length;
int temp,gap = arrLength/2;
while(gap>0) {
for(int i = gap; i<arrLength; i++) {
temp = arr[i];
int preIndex = i - gap;
while(preIndex >= 0 && arr[preIndex] < temp){
arr[preIndex + gap] = arr[preIndex];
preIndex -= gap;
}
arr[preIndex + gap] = temp;
}
gap /= 2;
}
}
/**
* 归并排序
* 和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间
* 归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。
* 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并
* @param arr 要排序的数组
*/
private static int[] mergeRightSort(int[] arr) {
int arrLength = arr.length;
if(arrLength < 2) return arr;
int mid = arrLength / 2;
int[] left = Arrays.copyOfRange(arr, 0, mid);
int[] right = Arrays.copyOfRange(arr, mid, arrLength);
return merge(mergeRightSort(left),mergeRightSort(right));
}
private static int[] merge(int[] left,int[] right) {
int resultLength = left.length+right.length;
int[] result = new int[resultLength];
for(int index = 0, i = 0, j = 0; index < resultLength; index++) {
if(i >= left.length)
result[index] = result[j++];
else if (j > right.length)
result[index] = left[i++];
else if (left[i] > right[j])
result[index] = right[j++];
else
result[index] = left[i++];
}
return result;
}
/**
* 快速排序
* 从数列中挑出一个元素，称为 “基准”（pivot）；
* 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
* 在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
* 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
* @param arr 要排序的数组
* @param start
* @param end
*/
private static int[] quickSort(int[] arr,int start,int end) {
int arrLength = arr.length;
if(arrLength <1 || start < 0 || end >= arrLength || start > end) return null;
int smallIndex = partition(arr, start, end);
if(smallIndex > start)
quickSort(arr, start, smallIndex-1);
if(smallIndex < end)
quickSort(arr, smallIndex+1, end);
return arr;
}
/**
* 每一次固定一个位置
* 首先确定一个基准，然后将基准与数组中最后一个交换，然后设置一个最小的下标，遍历数组，如果数组小于最后一个元素，最小的索引小标加1，
* 然后与遍历的下标比较，如果小于遍历的下标就进行交换，遍历到最后将基准数归位
* @param arr
* @param start
* @param end
* @return
*/
private static int partition(int[] arr,int start,int end) {
int pivot = (int)(start + Math.random() * (end - start + 1));
int smallIndex = start - 1;
swap(arr, pivot, end);
for(int i = start; i <= end; i++) {
if(arr[i] <= arr[end]) {
smallIndex++;
if(i > smallIndex)
swap(arr, i, smallIndex);
}
}
return smallIndex;
}
/**
* 交换数组内两个元素
* @param array 要交换的数组
* @param i 要交换的数组下标
* @param j 要交换的数组下标
*/
private static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
/**
* 基数排序
* 取得数组中的最大数，并取得位数；
* arr为原始数组，从最低位开始取每个位组成radix数组；
* 对radix进行计数排序（利用计数排序适用于小范围数的特点）；
* @param array
*/
private static void RadixSort(int[] array) {
int arrLength = array.length;
if(array != null && arrLength >2) {
int max = array[0];
for(int i = 1; i< arrLength; i++) {
max = Math.max(max, array[i]);
}
int maxDigit = 0;
while(max != 0) {
max /= 10;
maxDigit ++;
}
int mod = 10, div = 1;
ArrayList<ArrayList<Integer>> bucketList = new ArrayList<ArrayList<Integer>>(10);
for(int i = 0; i < 10; i++){
bucketList.add(new ArrayList<Integer>());
}
for(int i = 0; i < maxDigit; i++, mod *= 10, div *= 10) {
for(int j = 0; j < arrLength; j++) {
int num = (array[j] % mod) / div;
bucketList.get(num).add(array[j]);
}
int index = 0;
for(int j = 0; j < bucketList.size(); j++) {
for(int k = 0; k < bucketList.get(j).size(); k++)
array[index++] = bucketList.get(j).get(k);
bucketList.get(j).clear();
}
}
}
}
/**
* 计数排序
* 找出待排序的数组中最大和最小的元素；
* 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
* 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
* 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
*/
private static void countSort(int[] arr) {
int arrLength = arr.length;
if(arrLength != 0 && arrLength != 1) {
int bias, min = arr[0], max = arr[0];
for(int i = 1; i < arrLength; i++) {
if(arr[i] > max)
max = arr[i];
if(arr[i] < min)
min = arr[i];
}
bias = 0 - min;
int[] bucket = new int[max - min + 1];
Arrays.fill(bucket, 0);
for(int i = 0; i < arrLength; i++) {
bucket[arr[i] + bias]++;
}
int index = 0, i = 0;
while(index < arrLength) {
if(bucket[i] != 0) {
arr[index] = i - bias;
bucket[i]--;
index++;
}else {
i++;
}
}
}
}
/**
* 桶排序是计数排序的升级版
* 设置定量列表（数组）当作空桶
* 遍历待排序序列，将数据一个一个放到对应的桶里面
* 对每个非空桶进行排序
* 把排好序的非空桶里的序列拼接在一起
* @param arr
*/
private static ArrayList<Integer> bucketSort(ArrayList<Integer> arr, int bucketSize) {
int arrLength = arr.size();
if(arrLength != 0 && arrLength != 1) {
int min = arr.get(0), max = arr.get(0);
for(int i = 1; i < arrLength; i++) {
int tempValue = arr.get(i);
if(tempValue > max)
max = tempValue;
if(tempValue < min)
min = tempValue;
}
int bucketCount = (max - min) / bucketSize + 1;
ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<ArrayList<Integer>>(bucketCount);
ArrayList<Integer> resultArr = new ArrayList<Integer>();
for(int i = 0; i < bucketCount; i++) {
bucketArr.add(new ArrayList<Integer>());
}
for(int i = 0; i < arrLength; i++) {
bucketArr.get((arr.get(i) - min) / bucketSize).add(arr.get(i));
}
for(int i = 0; i < bucketCount; i++) {
if(bucketSize == 1) {
for(int j = 0; j < bucketArr.get(i).size(); j++)
resultArr.add(bucketArr.get(i).get(j));
}else {
if(bucketCount == 1)
bucketSize--;
ArrayList<Integer> temp = bucketSort(bucketArr.get(i),bucketSize);
int tempSize = temp.size();
for(int j = 0; j < tempSize; j++)
resultArr.add(temp.get(j));
}
}
return resultArr;
}
return arr;
}
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
