包含了 冒泡,快速排序,选择排序,插入排序,希尔排序,堆排序,
归并排序,基数排序
package Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class SortAny {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = {32,43,23,13,5};
SortAny sortany = new SortAny();
// sortany.BubbleSort(array); //冒泡
// sortany.SelectSort(array); // 选择
// sortany.InsertSort(array); // 插入
// sortany.QuicksSort(array, 0, 4); // 快速排序
// sortany.sheelSort(array); // 希尔排序
// sortany.HeapSort(array); // 堆排序
// sortany.mergeSort(array,0,4); // 归并排序
sortany.Radixsort(array); // 基数排序
}
/*----------------------------------------------------------------*/
// 冒泡排序,32 ,43,23, 13, 5
// 思想:升序排序,将数据两两比较,每次把最大的那个排到最后面
// 第一趟排序 32 43 23 13 5 ----32 23 43 13 5 ----32 23 13 43 5 -----32 23 13 5 43
// 第二趟排序 23 32 13 5 43 -----23 13 32 5 43----- 23 13 5 32 43
// 第三趟排序 13 23 5 32 43----- 13 5 23 32 43
// 第四趟排序 5 13 23 32 43
public void BubbleSort(int[] array){
for (int i = 0; i < array.length-1; i++){
for(int j = 0; j<array.length - i -1; j++){
if(array[j]>array[j + 1]){
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
for (int k=0; k<array.length; k++){
System.out.print(array[k]+" ");
}
System.out.println();
}
}
/*----------------------------------------------------------------*/
//选择排序 思想:遍历整个数组,每次选择最小的一个放在最前面
// 第一趟排序
public void SelectSort(int[] array){
for(int i=0;i<array.length;i++){
int min=array[i];
int minIndex=i;
int j;
for(j=i;j<array.length;j++){
if(array[j]<min){
min=array[j];
minIndex=j;
}
}
array[minIndex]=array[i];
array[i]=min;
for (int k=0; k<array.length; k++){
System.out.print(array[k]+" ");
}
System.out.println();
}
}
/*----------------------------------------------------------------*/
// 直接插入排序 思想:将第一个数和第二个数排序,然后构成一个有序序列,再将下一个数插入到有序序列值中
// 第一趟插入排序:32 43 23 13 5
// 第二趟插入排序: 23 32 43 13 5
// 第三趟插入排序: 13 23 32 43 5
// 第四趟插入排序: 5 13 23 32 43
public void InsertSort(int[] array){
for(int i=1;i<array.length;i++){
for(int j=i;j>0;j--){
if(array[j]<array[j-1]){
int temp=array[j-1];
array[j-1]=array[j];
array[j]=temp;
}
}
for (int k=0; k<array.length; k++){
System.out.print(array[k]+" ");
}
System.out.println();
}
}
/*----------------------------------------------------------------*/
// 快速排序 思想 选择一个数为p,小于p的放在左边,大于p的放在右边,递归
public void QuicksSort(int[] array, int min, int max){
if(min<max){
int middle=OneQuickSort(array, min, max);
QuicksSort(array,min,middle-1);
QuicksSort(array,middle+1,max);
}
}
public int OneQuickSort(int[] array, int min, int max){
int temp=array[min];
while (min<max){
while (min<max && array[max]>=temp){
max--;
}
//出现了比temp要小的数,此时调整顺序
array[min]=array[max];
while(min<max && array[min]<=temp){
min++;
}
array[max]=array[min];
}
// 注意的是最后一定要把temp值赋给 array[min]
array[min]=temp;
for (int k=0; k<array.length; k++){
System.out.print(array[k]+" ");
}
System.out.println();
return min;
}
/*----------------------------------------------------------------*/
// 堆排序
//将序列构建成大顶堆。
//将根节点与最后一个节点交换,然后断开最后一个节点。
//重复第一、二步,直到所有节点断开。
public 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 void BuildMaxHeap(int[] data, int maxIndex){
int i=(maxIndex-1)/2; //从最后一个节点的父亲节点开始
int biggerIndex;
// 最后的一个父亲节点比较特殊,判断为单个孩子节点还是双孩子节点
biggerIndex=2*i+1;
if(2*i+2==maxIndex){ // 双个孩子节点,先比较这两个数据的大小,确定孩子节点中较大的一个
if(data[biggerIndex]<data[biggerIndex+1]){
biggerIndex=biggerIndex+1;
}
}
//判断孩子和父亲的大小
if(data[i]<data[biggerIndex]){
Swap(data,i,biggerIndex);
}
i--;
for(;i>=0;i--){
biggerIndex=2*i+1;
if(data[biggerIndex]<data[biggerIndex+1]){
biggerIndex=biggerIndex+1;
}
//判断孩子和父亲的大小
if(data[i]<data[biggerIndex]){
Swap(data,i,biggerIndex);
}
}
}
private void Swap(int[] data, int i, int j) {
// TODO Auto-generated method stub
int tmp=data[i];
data[i]=data[j];
data[j]=tmp;
}
/*----------------------------------------------------------------*/
// 归并排序
public static void mergeSort(int[] numbers, 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(numbers, i, i + (s - 1), i + (t - 1));
i += t;
}
if (i + (s - 1) < right)
merge(numbers, 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];
}
/*----------------------------------------------------------------*/
// 希尔排序
// 首先确定分的组数。
// 然后对组中元素进行插入排序。
// 然后将length/2,重复1,2步,直到length=0为止。
public 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 void Radixsort(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++;
} //建立10个队列;
List<ArrayList> queue = new ArrayList<ArrayList>(); for (int i = 0; i < 10; i++) {
ArrayList<Integer> queue1 = new ArrayList<Integer>(); queue.add(queue1);
} //进行time次分配和收集;
for (int i = 0; i < time; i++) { //分配数组元素;
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++;
}
}
}
}
}