八大排序总结

概述

	冒泡排序
	选择排序
	插入排序
	上述三个的复杂度都是O(n^2)
	希尔排序
	归并排序
	快速排序
	堆排序
	基数排序
	上述五个的复杂度都是O(nlogn)

冒泡排序

for(i=0;i<arr.length;i++)
{
for(j=0;j<arr.length-1;j++)
{
int temp;
if(arr[j]<arr[j+1])
{
temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}

选择排序

for(int i = 0;i<arr.length-1;i++)
{
for(int j = i +1;j<arr.length;j++)
{
int minIndex = i;//最小值的下标
int min = arr[i];//最小值的值
if(min>arr[j])//查询出最小值，并找到最小值的下标
{
min=arr[j];
minIndex = j;
}
//交换首位数值和查询到的最小值数据
arr[minIndex] = arr[i];
arr[i] = min;
}
}

插入排序

for(int i = 1;i<arr.length;i++) {
for(int j = i-1;j>=0;j–) {
if(arr[j]>arr[j+1])
{
int temp;
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
else
break;
}
}

希尔排序（难）

for(int gap = arr.length/2;gap>0;gap/=2) {
for(int i =gap; i<arr.length;i++) {
for(int j =i-gap;j>=0;j-=gap) {
if(arr[j]>arr[j+gap]) {
int temp = arr[j];
arr[j] = arr[j+gap];
arr[j+gap] = temp;
}
}
}
}

基数排序

int [][]bucket = new int[10][arr.length];
int [] elementCounts=new int[10];
int max=arr[0];
for(int h=1;h<arr.length;h++) {
if(max<arr[h]) {
max=arr[h];
}
}
int maxlength = (max +“”).length();
int n =1;
for(int m =0;m<maxlength;m++) {
for(int i =0;i<arr.length;i++) {
int element = arr[i]/n%10;
int count = elementCounts[element];
bucket[element][count]=arr[i];
elementCounts[element]++;
}
int index=0;
for(int j=0;j<elementCounts.length;j++) {
if(elementCounts[j]!=0) {
for(int l=0;l<elementCounts[j];l++) {
arr[index]=bucket[j][l];
index++;
}
}
elementCounts[j]=0;
}
n*=10;
}

堆排序

package 八大排序;
import java.util.Arrays;
public class HeapSort {
public static void main(String[] args) {
int[] arr = new int[] {2,4,6,3,9,8,7,1,0};
//构建大顶推
for(int p = arr.length-1;p>=0;p–) {
sort(arr,p,arr.length);
}
//堆底元素和堆顶元素进行互换，length的长度不断减少是为了保证当前最大值不再参与构建
for(int i = arr.length-1;i>0;i–) {
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
sort(arr,0,i);//每次进行大顶堆的构建之后，就将根元素和尾元素进行互换，并且length不断的减减，可以让大数据排除
}
System.out.println(Arrays.toString(arr));
}
public static void sort(int[] arr,int parent,int length) {
//定义左子树
int child = 2 * parent + 1;
while(child < length) {
//排序
//判断有没有右子树，以及比较左右子树的大小，然后让child指向大的那一个
int rchild = child + 1;
if(rchild<length && arr[rchild] > arr[child]) {
child++;
}
//父子节点进行对比交换
if(arr[parent]<arr[child]) {
//交换
int temp = arr[parent];
arr[parent] = arr[child];
arr[child] = temp;
parent = child;
child = child * 2 + 1;
}
else
break;
}
}
}

归并排序

package 八大排序;
import java.util.Arrays;
public class MergeSort {
public static void main(String[] args) {
int[] arr = new int[] {19,5,6,7,12,35,78,54,61};
mergeSort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
//采用递归进行拆分
private static void mergeSort(int[] arr, int left, int right) {
// TODO Auto-generated method stub
if(left>=right) {
return;
}
int mid = (left + right)/2;
mergeSort(arr,left,mid);
mergeSort(arr,mid+1,right);
merage(arr,left,mid,right);
}
//合并元素
private static void merage(int[] arr, int left, int mid, int right) {
// TODO Auto-generated method stub
//定义临时数组
int[] temp = new int[right - left +1];
//定义s1和s2
int s1 = left;
int s2 = mid +1;
int i = 0;//用于遍历临时数组
//将数据写入到临时数组中
while(s1<=mid && s2<=right) {
if(arr[s1]<=arr[s2]) {
temp[i] = arr[s1];
i++;
s1++;
}else {
temp[i] = arr[s2];
i ++;
s2 ++;
}
}
//判断s1当中是否还有数据
while(s1<=mid) {
temp[i] = arr[s1];
i++;
s1++;
}
//判断s2当中是否还有数据
while(s2<=right) {
temp[i] = arr[s2];
i ++;
s2 ++;
}
//将临时数组当中的数据放回原来数组
for(int j = 0;j<temp.length;j++)
arr[j+left] = temp[j];
}
}

快速排序

第一种方法：选择50作为基准数，把比50大的都放到右侧，比50小的都放到左侧，这一轮的时间复杂度是O（n）
public static void quickSort(int[] arr,int a,int b) {
int low = a;
int high = b;
//数据比基准数小的左移
while(low<high){
if(arr[low+1]<arr[low]) {
int temp = arr[low];
arr[low] = arr[low+1];
arr[low+1] = temp;
low++;
//数据比基准数大的右移
}else if(arr[low+1]>arr[low]) {
int temp = arr[high];
arr[high] = arr[low+1];
arr[low+1] = temp;
high–;
}
}
if(a<low-1) {
quickSort(arr,a,low-1);
}
if(low+1 < b){
quickSort(arr,low+1,b);
}
}
}
第二种方法：选择数组首位为基准数，然后定义两个游标放到数组的首尾，首游标对应的数组元素与基准数比较，比基准数小的时候游标做自增操作，尾游标相反的操作
public static void quickSort2(int[] grr ,int a,int b) {
int i= a;
int j = b;
int temp = grr[0];
while(i!=j) {
while(grr[i]<=temp&&i<=j)
i++;
while(grr[j]>=temp&&i<=j)
j–;
int swap = grr[i];
grr[i] = grr[j];
grr[j] = swap;
}
grr[0] = grr[i];
grr[i] = temp;
if(a<i-1)
quickSort2(grr,a,i-1);
if(i+1<b)
quickSort2(grr,i+1,b);
}
}