JAVA实现经典排序算法（冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序、快速排序）

冒泡排序

依次比较相邻的元素，若发现逆顺序，则交换。小的向前换，大的向后换，本次循环完毕之后再次从头开始扫描，直到某次扫描中没有元素交换，说明每个元素都不比它后面的元素大，至此排序完成。

import java.util.Arrays;
public class BubbleSort {
 public static void main(String[] args) {
  int[] arr=new int[] {5,7,2,9,4,1,0,5,7};
  System.out.println(Arrays.toString(arr));
  bubbleSort(arr);
  System.out.println(Arrays.toString(arr));
 }
 public static void bubbleSort(int[]  arr) {
  for(int i=0;i<arr.length-1;i++) {
   for(int j=0;j<arr.length-1-i;j++) {
    if(arr[j]>arr[j+1]) {
     int temp=arr[j];
     arr[j]=arr[j+1];
     arr[j+1]=temp;
    }
   }
  }
 }
}

结果展示

选择排序

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

import java.util.Arrays;
public class SelectSort {
 public static void main(String[] args) {
  int[] arr = new int[] {3,4,5,7,1,2,0,3,6,8};
  selectSort(arr);
  System.out.println(Arrays.toString(arr));
 }
 public static void selectSort(int[] arr) {
  for(int i=0;i<arr.length;i++) {
   int minIndex=i;
   for(int j=i+1;j<arr.length;j++) {
    if(arr[minIndex]>arr[j]) {
     minIndex=j;
    }
   }
   if(i!=minIndex) {
    int temp=arr[i];
    arr[i]=arr[minIndex];
    arr[minIndex]=temp;
   }
  }
 }
}

结果展示

插入排序

从第一个元素开始，该元素可以认为已经被排序
取出下一个元素，在已经排序的元素序列中从后向前扫描
如果该元素（已排序）大于新元素，将该元素移到下一位置
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
将新元素插入到该位置后
重复上面步骤

import java.util.Arrays;
public class InsertSort {
 public static void main(String[] args) {
  int[] arr = new int[] {5,3,2,8,5,9,1,0};
  insertSort(arr);
  System.out.println(Arrays.toString(arr));
 }
 public static void insertSort(int[] arr) {
  for(int i=1;i<arr.length;i++) {
   if(arr[i]<arr[i-1]) {
    int temp=arr[i];
    int j;
    for(j=i-1;j>=0&&temp<arr[j];j--) 
     arr[j+1]=arr[j];
    arr[j+1]=temp;
    }
    
   }
  }
 }

结果展示

希尔排序

希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

import java.util.Arrays;
public class ShellSort {
 public static void main(String[] args) {
  int[] arr = new int[] { 3, 5, 2, 7, 8, 1, 2, 0, 4, 7, 4, 3, 8 };
  System.out.println(Arrays.toString(arr));
  shellSort(arr);
  System.out.println(Arrays.toString(arr));
 }
 public static void shellSort(int[] arr) {
  int k = 1;
  for (int d = arr.length / 2; d > 0; d /= 2) {
   for (int i = d; i < arr.length; i++) {
    for (int j = i - d; j >= 0; j -= d) {
     if (arr[j] > arr[j + d]) {
      int temp = arr[j];
      arr[j] = arr[j + d];
      arr[j + d] = temp;
     }
    }
   }
   System.out.println( Arrays.toString(arr));
   k++;
  }
 }
}

结果展示

堆排序

在堆的数据结构中，堆中的最大值总是位于根节点(在优先队列中使用堆的话堆中的最小值位于根节点)。
堆中定义以下几种操作：
最大堆调整：将堆的末端子节点作调整，使得子节点永远小于父节
点创建最大堆：将堆所有数据重新排序
堆排序：移除位在第一个数据的根节点，并做最大堆调整的递归运算。

import java.util.Arrays;
public class HeapSort {
 public static void main(String[] args) {
  int[] arr = new int[] {9,6,8,7,0,1,10,4,2};
  heapSort(arr);
  System.out.println(Arrays.toString(arr));
 }
 public static void heapSort(int[] arr) {
  int start = (arr.length-1)/2;
  for(int i=start;i>=0;i--) {
   maxHeap(arr, arr.length, i);
  }
  for(int i=arr.length-1;i>0;i--) {
   int temp = arr[0];
   arr[0]=arr[i];
   arr[i]=temp;
   maxHeap(arr, i, 0);
  }
 }
 public static void maxHeap(int[] arr,int size,int index) {
  int leftNode = 2*index+1;
  int rightNode = 2*index+2;
  int max = index;
  if(leftNode<size&&arr[leftNode]>arr[max]) {
   max=leftNode;
  }
  if(rightNode<size&&arr[rightNode]>arr[max]) {
   max=rightNode;
  }
  if(max!=index) {
   int temp=arr[index];
   arr[index]=arr[max];
   arr[max]=temp;
   maxHeap(arr, size, max);
  }
 }
}

结果展示

归并排序

归并操作的工作原理如下：
第一步：申请空间，使其大小为两个已经 排序序列之和，该空间用来存放合并后的序列
第二步：设定两个 指针，最初位置分别为两个已经排序序列的起始位置
第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置重复步骤3直到某一指针超出序列尾
将另一序列剩下的所有元素直接复制到合并序列尾

import java.util.Arrays;
public class MergeSort {
 public static void main(String[] args) {
  int[] arr = new int[] {1,3,5,2,4,6,8,10};
  System.out.println(Arrays.toString(arr));
  mergeSort(arr, 0, arr.length-1);
  System.out.println(Arrays.toString(arr));
 }
 public static void mergeSort(int[] arr,int low,int high) {
  int middle=(high+low)/2;
  if(low<high) {
   mergeSort(arr, low, middle);
   mergeSort(arr, middle+1, high);
   merge(arr,low,middle,high);
  }
 }
 public static void merge(int[] arr,int low,int middle, int high) {
  int[] temp = new int[high-low+1];
  int i=low;
  int j=middle+1;
  int index=0;
  while(i<=middle&&j<=high) {
   if(arr[i]<=arr[j]) {
    temp[index]=arr[i];
    i++;
   }else {
    temp[index]=arr[j];
    j++;
   }
   index++;
  }
  while(j<=high) {
   temp[index]=arr[j];
   j++;
   index++;
  }
  while(i<=middle) {
   temp[index]=arr[i];
   i++;
   index++;
  }
  for(int k=0;k<temp.length;k++) {
   arr[k+low]=temp[k];
  }
 }
}

结果展示

快速排序

快速排序算法利用的是一趟快速排序,基本内容是选择一个数作为准基数,然后利用这个准基数将遗传数据分为两个部分,第一部分比这个准基数小,都放在准基数的左边,第二部分都比这个准基数大,放在准基数的右边.

import java.util.Arrays;
public class QuickSort {
 public static void main(String[] args) {
  int[] arr = new int[] {3,4,6,7,2,7,2,8,0,9,1};
  quickSort(arr,0,arr.length-1);
  System.out.println(Arrays.toString(arr));
 }
 public static void quickSort(int[] arr,int start,int end) {
  if(start<end) {
   int stard=arr[start];
   int low=start;
   int high=end;
   while(low<high) {
    while(low<high&&stard<=arr[high]) {
     high--;
    }
    arr[low]=arr[high];
    while(low<high&&arr[low]<=stard) {
     low++;
    }
    arr[high]=arr[low];
   }
   arr[low]=stard;
   quickSort(arr, start, low);
   quickSort(arr, low+1, end);
  }
 }
}

结果展示