JAVA中排序算法

一晚上终于写完了，初学者

插入排序：

import java.util.Scanner;

public class Charupaixu {
public static void insertSort(int[] a){//传递一个数组
int length=a.length;//数组长度将这个提取出来是为了提高速度
int insertNum;//要插入的数
for(int i=0;i<length;i++){//插入的次数
insertNum=a[i];//要插入的数
int j=i-1;//已经排好的序列元素个数
while(j>=0&&a[j]>insertNum){//序列从后到前循环将大于insertNum的数想后移动
a[j+1]=a[j];//元素移动一格
j--;
}
a[j+1]=insertNum;//将需要插入的数放在要插入的位置
}

}
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("请输入四个数字进行排序");
Scanner in=new Scanner(System.in);
int[] s=new int[4];
for(int i=0;i<s.length;i++){
s[i]=in.nextInt();
}
insertSort(s);
for(int j=0;j<s.length;j++){
System.out.print(s[j]+"\t");
}
}

}

堆排序：代码中有见解

import java.util.Arrays;
import java.util.Scanner;


public class Duipaixu {
/**
 * 将序列建成大顶堆即该完全二叉树中每一个节点的值均大于或等于他的两个子节点的值
 * 将根节点与最后一个节点交换，然后断开最后一个节点
 * 重复第一二部直到断开所有节点
 * @param args
 */
public static void heapSort(int[] a){
System.out.println("开始排序");
int arrayLength=a.length;//循环建堆
for(int i=0;i<arrayLength-1;i++){//建堆
buildMaxHeap(a,arrayLength-1-i);
swap(a,0,arrayLength-1-i);//交换堆定和最后一个元素
System.out.println(Arrays.toString(a));
}
}
private static void swap(int[] data,int i,int j){
int tmp=data[i];
data[i]=data[j];
data[j]=tmp;
}
private static void buildMaxHeap(int[] data,int lastIndex){
//对data数组从0到lastIndex间大顶堆
//从lastIndex处节点（最后一个节点)的父节点开始
for(int i=(lastIndex-1)/2;i>=0;i++){
//k保存正在判断的节点
int k=i;
//如果当前k节点的子节点存在
while(k*2+1<=lastIndex){
int biggerIndex=2*k+1;//k节点的左子节点的索引
//如果biggerIndex小于lastIndex,即biggerIndex+1代表的K节点的右子节点存在
if(biggerIndex<lastIndex){
if(data[biggerIndex]<data[biggerIndex+1]){//如果右子节点的值较大
biggerIndex++;//biggerIndex总是记录较大节点的索引
}
}
//如果k节点的值小于较大的子节点的值
if(data[k]<data[biggerIndex]){
swap(data,k,biggerIndex);//交换他们
//将biggerIndex赋予k开始while循环的下一次循环，重新保证k节点的值大于左右子节点的值
k=biggerIndex;
}else{
break;
}
}
}
}
public static void main(String[] args)throws Exception {
// TODO Auto-generated method stub
System.out.println("请输入四个数字进行排序");
Scanner in=new Scanner(System.in);
int[] s=new int[4];
for(int i=0;i<s.length;i++){
s[i]=in.nextInt();
}
heapSort(s);
for(int j=0;j<s.length;j++){
System.out.print(s[j]+" ");
}
}


}

归并排序：

import java.util.Scanner;


public class Guibingpaixu {
/**
 * 选择相邻的两个书组成一个有序序列
 * 选择相邻的两个有序序列组成一个有序的序列
 * 重复第二步直到全部组成一个有序序列
 * @param args
 */
public static void mergeSort(int[] number,int left,int right){
int t=1;//每组元素个数
int size=right-left+1;
while(t<size){
int s=t;//本次循环每组元素个数
t=2*s;
int i=left;
while(i+(t-1)<size){
merge(number,i,i+(s-1),i+(t-1));
i+=t;
}
if(i+(s-1)<right)
merge(number,i,i+(s-1),right);
}
}
private static void merge(int[] data,int p,int q,int r){
int[] B=new int[data.length];
int s=p;
int t=q+1;
int k=p;
while(s<=q&&t<=r){
if(data[s]<=data[t]){
B[k]=data[s];
s++;
}else{
B[k]=data[t];
t++;
}
k++;
}
if(s==q+1)
B[k++]=data[t++];
else
B[k++]=data[s++];
for(int i=p;i<=r;i++)
data[i]=B[i];
}

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("请输入四个数字进行排序");
Scanner in=new Scanner(System.in);
int[] s=new int[6];
for(int i=0;i<s.length;i++){
s[i]=in.nextInt();
}
mergeSort(s,0,5);
for(int j=0;j<s.length;j++){
System.out.print(s[j]+" ");
}
}


}
基数排序：

import java.util.ArrayList;
import java.util.Scanner;


public class Jishupaixu {
/**
 * 将所有的数的各位取出按照个位数进行排序，构成一个序列
 * 将心构成的所有的数的十位取出按照十位数进行排序构成一个序列
 * @param args
 */
public static void sort(int[] array){
int max=array[0];//首先确定排序的趟数
for(int i=1;i<array.length;i++){
if(array[i]>max){
max=array[i];
}
}
int time=0;
while(max>0){//判断是几位数
max/=10;
time++;
}
ArrayList<ArrayList> queue=new ArrayList<ArrayList>();//建立10个队列
for(int i=0;i<10;i++){
ArrayList<Integer> queuel=new ArrayList<Integer>();
queue.add(queuel);
}
for(int i=0;i<time;i++){//进行time次分配和收集
for(int j=0;j<array.length;j++){//分配数组元素
//得到数字 的第time+1位数
int x=array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10,i);
ArrayList<Integer> queue2=queue.get(x);
queue2.add(array[j]);
queue.set(x,queue2);
}
int count=0;//元素计数器
for(int k=0;k<10;k++){
while(queue.get(k).size()>0){
ArrayList<Integer>queue3=queue.get(k);
array[count]=queue3.get(0);
queue3.remove(0);
count++;
}
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("请输入四个数字进行排序");
Scanner in=new Scanner(System.in);
int[] s=new int[4];
for(int i=0;i<s.length;i++){
s[i]=in.nextInt();
}
sort(s);
for(int j=0;j<s.length;j++){
System.out.print(s[j]+" ");
}
}


}
快速排序:

import java.util.Scanner;


public class Kuaipai {
/**
 * 选择第一个数最为p小于p的数放在左边，大于P的数放在右边
 * 递归的将p左边后右边的数按照第一步进行直到不能递归
 * @param args
 */
public static void quickSort(int[] number,int start,int end){
if(start<end){
int base=number[start];//选定第一个值作为基准值
int temp;//临时中间值
int i=start,j=end;
do{
while((number[i]<base)&&(i<end))
i++;
while((number[j]>base)&&(j>start))
j--;
if(i<=j){
temp=number[i];
number[i]=number[j];
number[j]=temp;
i++;
j--;
}
}while(i<=j);
if(start<j)
quickSort(number,start,j);
if(end>j)
quickSort(number,i,end);

}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("请输入六个数字进行排序");
Scanner in=new Scanner(System.in);
int[] s=new int[6];
for(int i=0;i<s.length;i++){
s[i]=in.nextInt();
}
quickSort(s,0,5);
for(int j=0;j<s.length;j++){
System.out.print(s[j]+" ");
}
}


}
冒泡排序:

import java.util.Scanner;


public class Maopaopaixu {
/**
 * 将序列中所有元素亮亮比较将最大的放在最后面
 * 将剩余的序列中所有元素两两比较将最大的放在最后面
 * 重复第二步直到只剩下一个数
 * @param args
 */
public static void bubbleSort(int[] a){
int length=a.length;
int temp;
for(int i=0;i<length;i++){
for(int j=0;j<length-1;j++){
if(a[i]>a[j]){
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("请输入四个数字进行排序");
Scanner in=new Scanner(System.in);
int[] s=new int[4];
for(int i=0;i<s.length;i++){
s[i]=in.nextInt();
}
bubbleSort(s);
for(int j=0;j<s.length;j++){
System.out.print(s[j]+" ");
}
}


}
希尔排序:

import java.util.Scanner;


public class xierpaixu {
/**
 * 将数的个数设为N取奇数k=n/2将下标差值为k的数分为一组，构成有序序列
 * 比如5个数，K=2，即1和4一组，2和5一组这
 * 再去k=k/2将下标差值为k的数分为一组构成有序序列
 * 直到k=1执行简单的插入排序
 * @param args
 */
public static void sheelSort(int[] a){
int d=a.length;
while(d!=0){
d=d/2;
for(int x=0;x<d;x++){//分的组数
for(int i=x+d;i<a.length;i+=d){//组中的元素从第二个数开始
int j=i-d;//j为有序序列最后一位的位数
int temp=a[i];//要插入的元素插入排序
for(;j>=0&&temp<a[j];j-=d){//从后往前遍历
a[j+d]=a[j];//向后移动d位
}
a[j+d]=temp;
}
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("请输入五个数字进行排序");
Scanner in=new Scanner(System.in);
int[] s=new int[5];
for(int i=0;i<s.length;i++){
s[i]=in.nextInt();
}
sheelSort(s);
for(int j=0;j<s.length;j++){
System.out.print(s[j]+" ");
}
}
}

选择排序:

import java.util.Scanner;


public class xuanzepaixu {
/**
 * 遍历真个序列将最小的数放在最前面
 * 遍历剩下的序列将最小的数放在最前面
 * 直到剩下一个数
 * @param args
 */
public static void selectSort(int[] a){
int length=a.length;
for(int i=0;i<length;i++){//循环次数
int key=a[i];
int position=i;//位置
for(int j=i+1;j<length;j++){//选出最小的值和位置
if(a[j]<key){
key=a[j];
position=j;
}

}
a[position]=a[i];//交换位置
a[i]=key;
}
}


public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("请输入四个数字进行排序");
Scanner in=new Scanner(System.in);
int[] s=new int[4];
for(int i=0;i<s.length;i++){
s[i]=in.nextInt();
}
selectSort(s);
for(int j=0;j<s.length;j++){
System.out.print(s[j]+" ");
}
}
}