1.冒泡排序(Bubble Sort)
import java.util.Arrays;
public class BubbleSort_01 {
public static void main(String[] args) {
int a[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
int count=0;
for (int i = 0; i < a.length-1; i++) {
for (int j = 0; j < a.length-1-i; j++) {
if (a[j]>a[j+1]) {
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
count++;
}
}
System.out.println(Arrays.toString(a));
System.out.println("一共比较了:"+count+"次");
}
}
冒泡排序的优化1:
import java.util.Arrays;
public class BubbleSort1_01 {
public static void main(String[] args) {
int a[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
int count=0;
for (int i = 0; i < a.length-1; i++) {
boolean flag=true;
for (int j = 0; j < a.length-1-i; j++) {
if (a[j]>a[j+1]) {
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
flag=false;
}
count++;
}
if (flag) {
break;
}
}
System.out.println(Arrays.toString(a));
System.out.println("一共比较了:"+count+"次");
}
}
2.选择排序(Select Sort)
import java.util.Arrays;
public class SelectSort_02 {
public static void main(String[] args) {
int a[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
for (int i = 0; i < a.length-1; i++) {
int index=i;
for (int j = i+1; j < a.length; j++) {
if (a[j]<a[index]) {
index=j;
}
}
int temp=a[index];
a[index]=a[i];
a[i]=temp;
}
System.out.println(Arrays.toString(a));
}
}
3.插入排序(Insert Sort)
import java.util.Arrays;
public class InsertSort_03 {
public static void main(String[] args) {
int a[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
for (int i = 0; i < a.length; i++) {
int insertValue=a[i];
int insertIndex=i-1;
while (insertIndex>=0 && insertValue <a[insertIndex]) {
a[insertIndex+1]=a[insertIndex];
insertIndex--;
}
a[insertIndex+1]=insertValue;
}
System.out.println(Arrays.toString(a));
}
}
4.希尔排序(Shell Sort)
import java.util.Arrays;
public class ShellSort_04 {
public static void main(String[] args) {
int a[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
int count=0;
for (int gap=a.length / 2; gap > 0; gap = gap / 2) {
for (int i = gap; i < a.length; i++) {
for (int j = i - gap; j>=0; j=j-gap) {
if (a[j]>a[j+gap]) {
int temp=a[j];
a[j]=a[j+gap];
a[j+gap]=temp;
count++;
}
}
}
}
System.out.println(count);
System.out.println(Arrays.toString(a));
}
}
5.快速排序(Quick Sort)
参考这篇博客
import java.util.Arrays;
public class QuickSort_05 {
public static void main(String[] args) {
int a[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
quicksort(a,0,a.length-1);
System.out.println(Arrays.toString(a));
}
private static void quicksort(int[] a, int low, int high) {
int i,j;
if (low>high) {
return;
}
i=low;
j=high;
int temp=a[low];
while(i<j){
while ( temp<=a[j] && i<j) {
j--;
}
while ( temp>=a[i] && i<j) {
i++;
}
if (i<j) {
int t=a[i];
a[i]=a[j];
a[j]=t;
}
}
a[low]=a[i];
a[i]=temp;
quicksort(a, low, j-1);
quicksort(a, j+1, high);
}
}
6.归并排序(Merge Sort)
import java.util.Arrays;
public class MergeSort_06 {
public static void main(String[] args) {
int a[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
int temp[]=new int[a.length];
mergesort(a,0,a.length-1,temp);
System.out.println(Arrays.toString(a));
}
private static void mergesort(int[] a, int left, int right, int[] temp) {
if (left<right) {
int mid=(left+right)/2;
mergesort(a, left, mid, temp);
mergesort(a, mid+1, right, temp);
merge(a,left,right,mid,temp);
}
}
private static void merge(int[] a, int left, int right, int mid, int[] temp) {
int i=left;
int j=mid+1;
int t=0;
while (i<=mid && j<=right) {
if (a[i]<=a[j]) {
temp[t]=a[i];
t++;
i++;
}else {
temp[t]=a[j];
t++;
j++;
}
}
while (i<=mid) {
temp[t]=a[i];
t++;
i++;
}
while (j<=right) {
temp[t]=a[j];
t++;
j++;
}
t=0;
int tempLeft=left;
while (tempLeft<=right) {
a[tempLeft]=temp[t];
t++;
tempLeft++;
}
}
}
7.堆排序(Heap Sort)
堆排序
第一步:构建初始堆buildHeap, 使用sink(arr,i, length)调整堆顶的值;
第二步:将堆顶元素下沉 目的是将最大的元素浮到堆顶来,然后使用sink(arr, 0,length)调整;
堆排序图解:链接
public class Heap_Sort_07 {
public static void main(String[] args) {
int a[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};
sort(a);
System.out.println(Arrays.toString(a));
}
public static void sort(int[] arr) {
int length = arr.length;
buildHeap(arr,length);
for ( int i = length - 1; i > 0; i-- ) {
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
length--;
sink(arr, 0,length);
}
}
private static void buildHeap(int[] arr, int length) {
for (int i = length / 2; i >= 0; i--) {
sink(arr,i, length);
}
}
private static void sink(int[] arr, int index, int length) {
int leftChild = 2 * index + 1;
int rightChild = 2 * index + 2;
int present = index;
if (leftChild < length && arr[leftChild] > arr[present]) {
present = leftChild;
}
if (rightChild < length && arr[rightChild] > arr[present]) {
present = rightChild;
}
if (present != index) {
int temp = arr[index];
arr[index] = arr[present];
arr[present] = temp;
sink(arr, present, length);
}
}
}
8.计数排序 (Count Sort)
参考链接
算法的步骤如下:
- 找出待排序的数组array中最大的元素max
- 统计数组中每个值为 i 的元素出现的次数,存入数组 count 的第 i 项
- 对所有的计数累加(从 count中的第一个元素开始,每一项和前一项相加)
- 反向填充目标数组:将每个元素 i 放在新数组的第 count [i] 项,每放一个元素就将 count [i] 减去
import java.util.Arrays;
public class CountSort_08 {
public static void main(String[] args) {
int[] array = { 4, 2, 2, 8, 3, 3, 1 };
int max = findMaxElement(array);
int[] sortedArr = countingSort(array, max + 1);
System.out.println("计数排序后的数组: " + Arrays.toString(sortedArr));
}
private static int findMaxElement(int[] array) {
int max = array[0];
for (int val : array) {
if (val > max)
max = val;
}
return max;
}
private static int[] countingSort(int[] array, int range) {
int[] output = new int[array.length];
int[] count = new int[range];
for (int i = 0; i < array.length; i++) {
count[array[i]]++;
}
for (int i = 1; i < range; i++) {
count[i] = count[i] + count[i - 1];
}
for (int i = 0; i < array.length; i++) {
output[count[array[i]] - 1] = array[i];
count[array[i]]--;
}
return output;
}
}
9.桶排序(Bucket Sort)
参考链接
桶排序可以看成是计数排序的升级版,它将要排的数据分到多个有序的桶里,每个桶里的数据再单独排序,再把每个桶的数据依次取出,即可完成排序。
桶排序:将值为i的元素放入i号桶,最后依次把桶里的元素倒出来。
桶排序序思路:
- 设置一个定量的数组当作空桶子。
- 寻访序列,并且把项目一个一个放到对应的桶子去。
- 对每个不是空的桶子进行排序。
- 从不是空的桶子里把项目再放回原来的序列中。
public class BucketSort_09 {
public static void sort(int[] arr){
int max = arr[0];
int min = arr[0];
int length = arr.length;
for(int i=1; i<length; i++) {
if(arr[i] > max) {
max = arr[i];
} else if(arr[i] < min) {
min = arr[i];
}
}
int diff = max - min;
ArrayList<ArrayList<Integer>> bucketList = new ArrayList<>();
for(int i = 0; i < length; i++){
bucketList.add(new ArrayList<>());
}
float section = (float) diff / (float) (length - 1);
for(int i = 0; i < length; i++){
int num = (int) (arr[i] / section) - 1;
if(num < 0){
num = 0;
}
bucketList.get(num).add(arr[i]);
}
for(int i = 0; i < bucketList.size(); i++){
Collections.sort(bucketList.get(i));
}
int index = 0;
for(ArrayList<Integer> arrayList : bucketList){
for(int value : arrayList){
arr[index] = value;
index++;
}
}
}
}
10.基数排序(Raix Sort)
我们假设有一个待排序数组[53,3,542,748,14,214],那么如何使用基数排序对其进行排序呢?
首先我们有这样的十个一维数组,在基数排序中也叫桶。用桶排序实现。
第一轮,以元素的个位数进行区分:[542,53,3,14,214,748]
第二轮,以元素的十位数进行区分:[3,14,214,542,748,53]第三轮,以元素的百位数进行区分:[3,14,53,214,542,748]
import java.util.Arrays;
public class RaixSort_10 {
public static void main(String[] args) {
int[] arr = { 53, 3, 542, 748, 14, 214 };
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
int maxLength = (max + "").length();
int[][] bucket = new int[10][arr.length];
int[] bucketElementCounts = new int[10];
for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
for (int j = 0; j < arr.length; j++) {
int digitOfElement = arr[j] / n % 10;
bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
bucketElementCounts[digitOfElement]++;
}
int index = 0;
for (int k = 0; k < bucket.length; k++) {
if (bucketElementCounts[k] != 0) {
for (int l = 0; l < bucketElementCounts[k]; l++) {
arr[index++] = bucket[k][l];
}
}
bucketElementCounts[k] = 0;
}
}
System.out.println(Arrays.toString(arr));
}
}
基数排序是用空间换时间的经典算法,当数据足够多时,达到几千万级别时内存空间可能不够用了,发生堆内存溢出
————————————————
版权声明:本文为CSDN博主「~wangweijun」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/qq_42453117/article/details/100036347
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)