import java.util.Random;
//所有排序后为从小到大
public class Sort {
public static void main(String[] args) {
Sort s=new Sort();
int[] result = Sort.randomNumber(1,10000,1000);
/*for(int k =0 ;k<result.length;k++){
System.out.println(result[k]);
}*/
s.BubbleSort(result); //冒泡排序
for(int k =0 ;k<result.length;k++){
System.out.println(result[k]);
}
/*s.SelectionSort(result); //选择排序
for(int k =0 ;k<result.length;k++){
System.out.println(result[k]);
}*/
/*s.InsertSort(result); //插入排序
for(int k =0 ;k<result.length;k++){
System.out.println(result[k]);
}*/
/*s.ShellSort(result); //希尔排序
for(int k =0 ;k<result.length;k++){
System.out.println(result[k]);
}*/
/*int start = 0; //快速排序
int end = result.length-1;
s.QuickSort(result, start, end);
for(int k =0 ;k<result.length;k++){
System.out.println(result[k]);
}*/
/*s.MergeSort(result); //归并排序
for(int k =0 ;k<result.length;k++){
System.out.println(result[k]);
}*/
/*s.HeapSort(result); //堆排序
for(int k =0 ;k<result.length;k++){
System.out.println(result[k]);
}*/
}
public static int[] randomNumber(int min,int max,int n){
//判断是否已经达到索要输出随机数的个数
if(n>(max-min+1) || max <min){
return null;
}
int[] result = new int[n]; //用于存放结果的数组
int count = 0;
while(count <n){
int num = (int)(Math.random()*(max-min))+min;
boolean flag = true;
for(int j=0;j<n;j++){
if(num == result[j]){
flag=false;
break;
}
}
if(flag){
result[count] = num;
count++;
}
}
return result;
}
public void BubbleSort(int[] a) {
int temp=0;
for(int i=a.length-1;i>0;i--) {
for(int j=0;j<i;j++) {
if(a[j]>a[j+1]) {
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}
public void SelectionSort(int[] a) {
for(int i=0;i<a.length-1;i++) {
int k=i;
for(int j=k+1;j<a.length;j++) {
if(a[k]>a[j]) {
k=j;
}
}
if(k!=i) {
int temp = a[i];
a[i] = a[k];
a[k] = temp;
}
}
}
public void InsertSort(int[] a) {
int temp=0;
for(int i=1;i<a.length;i++) {
for(int j=i;j>0;j--) {
if(a[j]<a[j-1]) {
temp=a[j];
a[j]=a[j-1];
a[j-1]=temp;
}
}
}
}
public void ShellSort(int[] a){
if(a == null || a.length <= 1){
return;
}
//增量
int incrementNum = a.length/2;
while(incrementNum >=1){
for(int i=0;i<a.length;i++){
//进行插入排序
for(int j=i;j<a.length-incrementNum;j=j+incrementNum){
if(a[j]>a[j+incrementNum]){
int temple = a[j];
a[j] = a[j+incrementNum];
a[j+incrementNum] = temple;
}
}
}
//设置新的增量
incrementNum = incrementNum/2;
}
}
public void QuickSort(int[] a,int low,int high){
int start = low;
int end = high;
int key = a[low];
while(end>start){
//从后往前比较
while(end>start&&a[end]>=key) //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
end--;
if(a[end]<=key){
int temp = a[end];
a[end] = a[start];
a[start] = temp;
}
//从前往后比较
while(end>start&&a[start]<=key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
start++;
if(a[start]>=key){
int temp = a[start];
a[start] = a[end];
a[end] = temp;
}
//此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
}
//递归
if(start>low)
QuickSort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
if(end<high)
QuickSort(a,end+1,high);//右边序列。从关键值索引+1到最后一个
}
public void MergeSort(int[] a) {
sort(a, 0, a.length - 1);
}
public static void sort(int[] a, int left, int right) {
if (left >= right)
return;
// 找出中间索引
int center = (left + right) / 2;
// 对左边数组进行递归
sort(a, left, center);
// 对右边数组进行递归
sort(a, center + 1, right);
// 合并
merge(a, left, center, right);
}
/**
* 将两个数组进行归并，归并前面2个数组已有序，归并后依然有序
*
* @param a
* 数组对象
* @param left
* 左数组的第一个元素的索引
* @param center
* 左数组的最后一个元素的索引，center+1是右数组第一个元素的索引
* @param right
* 右数组最后一个元素的索引
*/
public static void merge(int[] a, int left, int center, int right) {
// 临时数组
int[] tmpArr = new int[a.length];
// 右数组第一个元素索引
int mid = center + 1;
// third 记录临时数组的索引
int third = left;
// 缓存左数组第一个元素的索引
int tmp = left;
while (left <= center && mid <= right) {
// 从两个数组中取出最小的放入临时数组
if (a[left] <= a[mid]) {
tmpArr[third++] = a[left++];
} else {
tmpArr[third++] = a[mid++];
}
}
// 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）
while (mid <= right) {
tmpArr[third++] = a[mid++];
}
while (left <= center) {
tmpArr[third++] = a[left++];
}
// 将临时数组中的内容拷贝回原数组中
// （原left-right范围的内容被复制回原数组）
while (tmp <= right) {
a[tmp] = tmpArr[tmp++];
}
}
public static void swap(int[] a, int i, int j) {
if (i == j) {
return;
}
a[i] = a[i] + a[j];
a[j] = a[i] - a[j];
a[i] = a[i] - a[j];
}
public void HeapSort(int[] a) {
for (int i = 0; i < a.length; i++) {
createMaxdHeap(a, a.length - 1 - i);
swap(a, 0, a.length - 1 - i);
}
}
public static void createMaxdHeap(int[] a, int lastIndex) {
for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
// 保存当前正在判断的节点
int k = i;
// 若当前节点的子节点存在
while (2 * k + 1 <= lastIndex) {
// biggerIndex总是记录较大节点的值,先赋值为当前判断节点的左子节点
int biggerIndex = 2 * k + 1;
if (biggerIndex < lastIndex) {
// 若右子节点存在，否则此时biggerIndex应该等于 lastIndex
if (a[biggerIndex] < a[biggerIndex + 1]) {
// 若右子节点值比左子节点值大，则biggerIndex记录的是右子节点的值
biggerIndex++;
}
}
if (a[k] < a[biggerIndex]) {
// 若当前节点值比子节点最大值小，则交换2者得值，交换后将biggerIndex值赋值给k
swap(a, k, biggerIndex);
k = biggerIndex;
} else {
break;
}
}
}
}
}
浙公网安备 33010602011771号