快速排序,堆排序,计数排序,基数排序,桶排序

import java.util.Arrays;

public class KuaiSu {
public static void main(String[] args) {
int a[]=new int[] {5,22,10,52,3,1,7,100,-1};;
sort(a,0,a.length-1);
System.out.println(Arrays.toString(a));
}

public static void sort(int [] a) {
sort(a ,0,a.length);
}
public static void sort(int []a,int startIndex,int endIndex) {
if(endIndex<=startIndex) {
return;//判断
}
int baseIndex=partition(a,startIndex,endIndex);
sort(a,startIndex,baseIndex-1);//左边排序
sort(a,baseIndex+1,endIndex);//右边排序
}
private static int partition(int []a,int startIndex,int endIndex) {
int base =a[startIndex];//基准值
int left=startIndex;//初始下标
int right=endIndex;
while(true) {
while(a[left]<base)//左边与基准值
{
left++;
if(left==right) {
break;
}
}
while(a[right]>base) //右边与基准值
{
right--;
if(left==right) {
break;
}
}
if(left>=right)//两边遇到结束循环
{
break;
}
//左右交换
int temp=a[left];
a[left]=a[right];
a[right]=temp;
}
a[left]=base;
return right;
}

}

快速排序的思想,在数组中选择一个基准值,让基准值的左右两边与基准则进行比较,然后小于基准值的放在左边,大于基准值放在右边,左右两边指针交替移动,左边向右,右边向左,直到左右两个指针相遇后就结束循环

 

堆排序

import java.util.Arrays;

public class Testtest {
public static void main(String[] args) {
int a[]=new int[] {5,10,3,1,7,-1};
int b[]=new int[] {5,10,3,1,7,-1};
sort(a,a.length,0);
sort2(b,b.length);
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));

}
public static void change(int []a,int i,int j) {
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}
public static void sort(int a[],int n,int i) {

//构成堆
int last=n-1;
int parent=(last-1)/2;
for(int k=parent-1;k>=0;k--) {
for(int j=0;j<a.length;j++) {
int max=i;
int left=2*i+1;
int right=2*i+2;
if(left<n && a[left]>a[max]){
max=left;
}
if(right<n && a[right]>a[max]) {
max=right;
}
if(max!=i) {
change(a,max,i);
sort(a,n,max);
}
}
}

}
public static void sort2(int []a,int n) {
sort(a,a.length,0);
for(int i=n-1;i>=0;i--) {
change(a,i,0);
sort(a,i,0);
}
}
}

 

 

j计数排序

 

import java.util.Arrays;
//计数排序
public class JiShu {

public static void main(String[] args) {
int a[]=new int[] {5,22,10,52,3,1,7,1,1,5,5};
int[]c=sort(a);
System.out.println(Arrays.toString(a));

}
public static int[] sort(int []a) {
int max=a[0];
int min=a[a.length-1];
for(int i=0;i<a.length;i++) {
if(a[i]>max) {
max=a[i];
}
if(a[i]<min) {
min=a[i];
}
}
int []b=new int [max-min+1];
for(int i=0;i<a.length;i++) {
int num=a[i];
b[num] ++;//计数数组，统计数组a中元素出现的次数，
}

int []c=new int [a.length];//遍历数组b,然后放入c数组
for(int i=1;i<b.length;i++) {
b[i]=b[i]+b[i-1];//累加数组,对应相同元素排列最后的一个下标值
}
for(int i=a.length-1;i>=0;i--) {
c[--b[a[i]]]=a[i];//从后向前迭代一遍，然后找到对应的数字放在对应的位置（累加数组计算了每个位置）
}

return c;

}

}

计数排序

主要思想就是定义一个新的数组，数组长度为原数组的最大值和最小值+1，然后循环遍历原数组，原数组的元素值为新数组的下标，并存入新数组的相应位置，最后遍历新数组按顺序取出

 

 

基数排序

import java.util.ArrayList;
import java.util.Arrays;

//基数排序
public class JiShu2 {
public static void main(String[] args) {
int a[]=new int[] {5,227,1011,520,3,1,79};
int[] b=sort(a);
System.out.println(Arrays.toString(a));
}
public static int[] sort(int []a) {
int max=a[0];
int index=0;
int[] count=new int[10];//桶
int[] b=new int [a.length];
for(int i=0;i<a.length;i++) {
if(a[i]>max) {
max=a[i];
}
}
while(max>0) {//计算数组中最大的数为几位数
max=max/10;
index++;
}
//System.out.println(index);
for(int i=0;i<index;i++) {
int d=(int)Math.pow(10,i);//10的i次方
for(int j=0;j<a.length;j++) {
int num=a[j]/d%10;//求基数()
count[num]++;//求出的基数放在桶里
}

for(int m=1;m<count.length;m++) {
count[m]=count[m]+count[m-1];//累加数组,对应相同元素排列最后的一个下标值
}
for(int n=a.length-1;n>=0;n--) {
int num=a[n]/d % 10;
b[--count[num]]=a[n];//从后向前迭代一遍，然后找到对应的数字放在对应的位置（累加数组计算了每个位置）
}
System.arraycopy(b, 0, a, 0, a.length);//把b数组的元素copy到a数组里
Arrays.fill(count, 0);
}
return b;
}

}

基数排序基本思想 对数组内元素 每次循环对10*循环次数取余（可提前找出数组中最大值的位数，决定循环取余），也就是对个位大小排序放入9个桶中，然后百位，然后千位，，，，排完后取出来就可以了

 

桶排序

基数排序个计数排序都是桶排序的思想，把元素按一定顺序放入桶，最后循环取出

堆排序

import java.util.Arrays;

public class Dui {

public static void main(String[] args) {
int a[]=new int[] {5,22,10,52,3,1,7,100,-1};
int b[]=new int[] {5,22,10,52,3,1,7,100,-1};
int c[]=new int[] {5,22,10,52,3,1,7,100,-1};

sort(a,a.length,0);
sort2(b,b.length);
sort3(c, c.length);
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));
System.out.println(Arrays.toString(c));
}

public static void change(int []a,int i,int j) {
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}
public static void sort(int a[],int n,int i)//完全二叉树
{
for(int j=0;j<a.length;j++) {
int max=i;
int left=2*i+1;
int right=2*i+2;
if(left<n && a[left]>a[max]){
max=left;
}
if(right<n && a[right]>a[max]) {
max=right;
}
if(max!=i) {
change(a,max,i);
sort(a,n,max);
}
}
}

public static void sort2(int a[],int n)//堆
{
int last=n-1;//最后一个节点
int parent=(last-1)/2;//最后一个节点的父类
for(int i=parent-1;i>=0;i--) {
sort(a,n,i);
}

}
public static void sort3(int tree[],int n) {
sort2(tree,n);//建立一个堆
for(int i=n-1;i>=0;i--) {
change(tree,i,0);//交换根节点和最后一个节点的位置
sort(tree,i,0);//剪叶子
}
}
}

堆排序主要思想 什么是完全二叉树（有了左节点才能有右节点），什么是堆（堆是完全二叉树，且堆的任何子节点都不大于父节点）

把数组转化为堆，然后把根节点和最后一个节点交换位置然后剪掉最后一个节点（剪下的节点总是为堆中最大的值），在对剩下的完全二叉树进行排序成堆，循环多次，直至只剩下一个节点。对剪下的节点进行逆序输出，最后为从小到大输出