1.选择排序
package class01;
import java.util.Arrays;
public class SelectionSort {
public static void main(String[] args){
int maxSize=100;
int maxValue=1000;
int times=50;
for(int i=0;i<times;i++){
System.out.println("第"+(i+1)+"次测试:");
int[] arr1=getRandomArray(maxSize,maxValue);
// printArray(arr1);
int[] arr2=copyArray(arr1);
// printArray(arr2);
selectionSort(arr1);
Arrays.sort(arr2);
if(isEqual(arr1,arr2)){
System.out.println("Successful!");
}else{
System.out.println("Unsuccessful!");
printArray(arr1);
System.out.println("???????????????");
printArray(arr2);
break;
}
}
}
//输出数组
public static void printArray(int[] arr){
for(int i=0; i<arr.length;i++){
System.out.println(arr[i]);
}
}
//判断两个数组中的数是否相等
public static boolean isEqual(int[] arr1,int[] arr2){
if((arr1==null &&arr2!=null)||(arr2==null &&arr1!=null)){
return false;
}
if(arr1.length!=arr2.length){
return false;
}
for(int i=0; i<arr1.length;i++){
if(arr1[i]!=arr2[i]){
return false;
}
}
return true;
}
//交换数组中的两个数
public static void swap(int i, int minIndex, int[] arr){
int a=arr[i];
arr[i]=arr[minIndex];
arr[minIndex]=a;
}
//选择排序
public static void selectionSort(int[] arr){
if(arr==null || arr.length<2){
return;
}
for(int i=0; i<arr.length ;i++){
int minIndex=i;
for(int j=i;j<arr.length;j++){
if(arr[minIndex]>arr[j]){
minIndex=j;
}
}
swap(i,minIndex,arr);
}
}
//随机生成数组
public static int[] getRandomArray(int maxSize, int maxValue){
int[] arr= new int[(int)((maxSize+1)*Math.random())] ;
for(int i=0; i<arr.length;i++){
arr[i]=(int)((maxValue+1)*Math.random())-(int)(maxValue*Math.random());
}
return arr;
}
//复制数组
public static int[] copyArray(int[] arr){
if(arr==null){
return null;
}
int[] arr2=new int[arr.length];
for(int i=0;i<arr.length;i++){
arr2[i]=arr[i];
}
return arr2;
}
}
2.冒泡排序
package class01;
import java.util.Arrays;
public class BubbleSort {
public static void main(String[] args) {
int maxSize=100;
int maxValue=1000;
int times=50;
for(int i=0; i<times;i++){
System.out.println(i+1);
double[] arr1=getRandomArray(maxSize,maxValue);
double[] arr2=copyArray(arr1);
BubbleSort(arr1);
Arrays.sort(arr2);
if(isEqual(arr1,arr2)){
System.out.println("Successful!");
}else{
System.out.println("Unsuccessful!");
break;
}
}
}
//判断两个数组是否相等
public static boolean isEqual(double[] arr1,double[] arr2){
if((arr1==null && arr2!=null)||(arr2==null && arr2!=null)){
return false;
}
if(arr1.length!=arr2.length){
return false;
}
for(int i=0;i<arr1.length;i++){
if(arr1[i]!=arr2[i]){
return false;
}
}
return true;
}
//随机生成数组
public static double[] getRandomArray(int maxSize, int maxValue){
double[] arr=new double[(int)((maxSize+1)*Math.random())];
for(int i=0;i<arr.length;i++){
arr[i]=(maxValue)*Math.random()-maxValue*Math.random();
}
return arr;
}
//复制数组
public static double[] copyArray(double[] arr){
if(arr==null){
return null;
}
double[] arr2=new double[arr.length];
for(int i=0;i<arr.length;i++){
arr2[i]=arr[i];
}
return arr2;
}
//交换数组中的两个数
public static void swap(int i,int j,double[] arr){
double a=arr[i];
arr[i]=arr[j];
arr[j]=a;
}
public static void BubbleSort(double[] arr){
if((arr==null)||(arr.length<2)){
return;
}
for(int i=0;i< arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
swap(j,j+1,arr);
}
}
}
}
}
3.插入排序
00范围有序;01范围有序……;0~N范围有序。数据状况不同会导致时间复杂度不同。
package class01;
import java.util.Arrays;
public class InsertionSort {
public static void main(String[] args) {
int maxSize=100;
int maxValue=1000;
int times=100;
for(int i=0; i<times;i++){
System.out.println(i+1);
double[] arr1=getRandomArray(maxSize,maxValue);
double[] arr2=copyArray(arr1);
insertionSort(arr1);
Arrays.sort(arr2);
if(isEqual(arr1,arr2)){
System.out.println("Successful!");
}else{
System.out.println("Unsuccessful!");
break;
}
}
}
//判断两个数组是否相等
public static boolean isEqual(double[] arr1,double[] arr2){
if((arr1==null && arr2!=null)||(arr2==null && arr2!=null)){
return false;
}
if(arr1.length!=arr2.length){
return false;
}
for(int i=0;i<arr1.length;i++){
if(arr1[i]!=arr2[i]){
return false;
}
}
return true;
}
//随机生成数组
public static double[] getRandomArray(int maxSize, int maxValue){
double[] arr=new double[(int)((maxSize+1)*Math.random())];
for(int i=0;i<arr.length;i++){
arr[i]=(maxValue)*Math.random()-maxValue*Math.random();
}
return arr;
}
//复制数组
public static double[] copyArray(double[] arr){
if(arr==null){
return null;
}
double[] arr2=new double[arr.length];
for(int i=0;i<arr.length;i++){
arr2[i]=arr[i];
}
return arr2;
}
//交换数组中的两个数
public static void swap(int i,int j,double[] arr){
double a=arr[i];
arr[i]=arr[j];
arr[j]=a;
}
//插入排序
public static void insertionSort(double[] arr){
if (arr == null || arr.length < 2) {
return;
}
for(int i=1;i<arr.length;i++){
for(int j=i;j>0;j--){
if(arr[j]<arr[j-1]){
swap(j,j-1,arr);
}
}
}
}
}
4.归并排序
找到中点,左侧排好序,右侧排好序;开辟一个新的空间,合并在一起,比较左右两侧,谁小先拷贝谁,并且指针移动;然后拷贝回原数组。使用递归实现
package class01;
import java.util.Arrays;
//归并排序
public class MergeSort {
public static void main(String[] args) {
int maxSize=100;
int maxValue=1000;
int times=100;
for(int i=0; i<times;i++){
System.out.println(i+1);
double[] arr1=getRandomArray(maxSize,maxValue);
double[] arr2=copyArray(arr1);
//注意一定要是arr1.length-1
mergeSort(0,arr1.length-1,arr1,new double[arr1.length]);
Arrays.sort(arr2);
if(isEqual(arr1,arr2)){
System.out.println("Successful!");
}else{
System.out.println("Unsuccessful!");
break;
}
}
}
//判断两个数组是否相等
public static boolean isEqual(double[] arr1,double[] arr2){
if((arr1==null && arr2!=null)||(arr2==null && arr2!=null)){
return false;
}
if(arr1.length!=arr2.length){
return false;
}
for(int i=0;i<arr1.length;i++){
if(arr1[i]!=arr2[i]){
return false;
}
}
return true;
}
//随机生成数组
public static double[] getRandomArray(int maxSize, int maxValue){
double[] arr=new double[(int)((maxSize+1)*Math.random())];
for(int i=0;i<arr.length;i++){
arr[i]=(maxValue)*Math.random()-maxValue*Math.random();
}
return arr;
}
//复制数组
public static double[] copyArray(double[] arr){
if(arr==null){
return null;
}
double[] arr2=new double[arr.length];
for(int i=0;i<arr.length;i++){
arr2[i]=arr[i];
}
return arr2;
}
public static void mergeSort(int L,int R,double[] arr,double[] tempArr){
//注意一定要有L<R这个判定条件
if(L<R){
int mid=(L+R)/2;
mergeSort(L,mid,arr,tempArr);
mergeSort(mid+1,R,arr,tempArr);
sort(L,mid,R,arr,tempArr);
}
}
public static void sort(int L,int mid,int R,double[] arr,double[] tempArr){
int index=0;
int i=L;
int j=mid+1;
while(i<=mid&&j<=R){
if(arr[i]<arr[j]){
tempArr[index]=arr[i];
index++;
i++;
}else{
tempArr[index]=arr[j];
index++;
j++;
}
}
if(j>R){
for(;i<=mid;i++){
tempArr[index]=arr[i];
index++;
}
}else{
for(;j<=R;j++){
tempArr[index]=arr[j];
index++;
}
}
for(int k=L,g=0;k<=R;k++,g++){
arr[k]=tempArr[g];
}
}
}
5.快速排序1.0
使用最后一个值做为划分值,做到小于的在左边,大于等于的在右边;最后一个数跟大于区的第一个数做交换;左侧和右侧分别递归。
package class01;
import java.util.Arrays;
//使用最后一个值做为划分值,做到小于的在左边,大于等于的在右边;
// 最后一个数跟大于区的第一个数做交换;左侧和右侧分别递归。
public class QuickSort1 {
public static void main(String[] args) {
int maxSize=100;
int maxValue=1000;
int times=100;
for(int i=0; i<times;i++){
System.out.println(i+1);
double[] arr1=getRandomArray(maxSize,maxValue);
double[] arr2=copyArray(arr1);
//注意一定要是arr1.length-1
quickSort1(arr1,0, arr1.length-1);
Arrays.sort(arr2);
if(isEqual(arr1,arr2)){
System.out.println("Successful!");
}else{
System.out.println("Unsuccessful!");
break;
}
}
}
//判断两个数组是否相等
public static boolean isEqual(double[] arr1,double[] arr2){
if((arr1==null && arr2!=null)||(arr2==null && arr2!=null)){
return false;
}
if(arr1.length!=arr2.length){
return false;
}
for(int i=0;i<arr1.length;i++){
if(arr1[i]!=arr2[i]){
return false;
}
}
return true;
}
//随机生成数组
public static double[] getRandomArray(int maxSize, int maxValue){
double[] arr=new double[(int)((maxSize+1)*Math.random())];
for(int i=0;i<arr.length;i++){
arr[i]=(maxValue)*Math.random()-maxValue*Math.random();
}
return arr;
}
//复制数组
public static double[] copyArray(double[] arr){
if(arr==null){
return null;
}
double[] arr2=new double[arr.length];
for(int i=0;i<arr.length;i++){
arr2[i]=arr[i];
}
return arr2;
}
public static void swap(int i,int j,double[] arr){
double a=arr[i];
arr[i]=arr[j];
arr[j]=a;
}
public static void quickSort1(double[] arr,int L,int R){
if(L<R){
int position=partition(arr,L,R);
quickSort1(arr,L,position-1);
quickSort1(arr,position+1,R);
}
}
public static int partition(double[] arr, int L, int R){
double pivot=arr[R];
int point=L;
for(int i=L;i<=R;i++){
if(arr[i]<pivot){
swap(i,point,arr);
point++;
}
}
swap(point,R,arr);
return point;
}
}
6.快速排序2.0
使用最后一个值作为划分,做到小于、等于和大于区;分别在小于和大于区做划分。
package class01;
import java.util.Arrays;
//快速排序2.0:使用最后一个值作为划分,做到小于、等于和大于区;分别在小于和大于区做划分。
public class QuickSort2 {
public static void main(String[] args) {
int maxSize = 10;
int maxValue = 1000;
int times = 100;
for (int i = 0; i < times; i++) {
System.out.println(i + 1);
double[] arr1 = getRandomArray(maxSize, maxValue);
double[] arr2 = copyArray(arr1);
//注意一定要是arr1.length-1
quickSort2(arr1, 0, arr1.length - 1);
Arrays.sort(arr2);
if (isEqual(arr1, arr2)) {
System.out.println("Successful!");
} else {
printArray(arr1);
System.out.println("???????");
printArray(arr2);
System.out.println("Unsuccessful!");
break;
}
}
}
//判断两个数组是否相等
public static boolean isEqual(double[] arr1,double[] arr2){
if((arr1==null && arr2!=null)||(arr2==null && arr2!=null)){
return false;
}
if(arr1.length!=arr2.length){
return false;
}
for(int i=0;i<arr1.length;i++){
if(arr1[i]!=arr2[i]){
return false;
}
}
return true;
}
//打印数组
public static void printArray(double[] arr){
for(int i=0; i<arr.length;i++){
System.out.println(arr[i]);
}
}
//随机生成数组
public static double[] getRandomArray(int maxSize, int maxValue){
double[] arr=new double[(int)((maxSize+1)*Math.random())];
for(int i=0;i<arr.length;i++){
arr[i]=(maxValue)*Math.random()-maxValue*Math.random();
}
return arr;
}
//复制数组
public static double[] copyArray(double[] arr){
if(arr==null){
return null;
}
double[] arr2=new double[arr.length];
for(int i=0;i<arr.length;i++){
arr2[i]=arr[i];
}
return arr2;
}
public static void swap(int i,int j,double[] arr){
double a=arr[i];
arr[i]=arr[j];
arr[j]=a;
}
public static int[] partition(double[] arr,int L,int R){
double pivot=arr[R];
int[] point=new int[2];
int point_L=L;
int point_R=R;
int i=L;
while(i<=point_R){
if(arr[i]<pivot){
swap(i,point_L,arr);
point_L++;
i++;
}else if(arr[i]>pivot){
swap(i,point_R,arr);
point_R--;
}else{
i++;
//只有i++,没有其他操作
}
}
point[0]=point_L-1;
point[1]=point_R+1;
return point;
}
public static void quickSort2(double[] arr,int L,int R){
if(L<R){
int[] position= partition(arr,L,R);
int position_L=position[0];
int position_R=position[1];
quickSort2(arr,L,position_L);
quickSort2(arr,position_R,R);
}
}
}
7.快速排序3.0
随机选一个数作为划分值。
package class01;
import java.util.Arrays;
//快速排序3.0:随机选一个数作为划分值。还是分三段。
public class QuickSort3 {
public static void main(String[] args) {
int maxSize=100;
int maxVaule=100;
int times=100;
for(int i=0;i<times;i++){
System.out.println(i+1);
int[] arr1=getRandomArray(maxSize,maxVaule);
int[] arr2=copyArray(arr1);
quickSort3(0, arr1.length-1,arr1);
Arrays.sort(arr2);
if(isEqual(arr1,arr2)){
System.out.println("Successful!");
}else{
System.out.println("Unsuccessful!");
break;
}
}
}
public static int[] getRandomArray(int maxSize, int maxValue){
int[] arr=new int[(int)((maxSize+1)*Math.random())];
for(int i=0;i<arr.length;i++){
arr[i]=(int)((maxValue+1)*Math.random())-(int)(maxValue*Math.random());
}
return arr;
}
public static int[] copyArray(int[] arr){
if(arr==null){
return null;
}
int[] arr1=new int[arr.length];
for(int i=0;i<arr.length;i++){
arr1[i]=arr[i];
}
return arr1;
}
public static boolean isEqual(int[] arr1,int[] arr2){
if((arr1==null && arr2!=null)|| (arr2==null && arr1!=null)){
return false;
}
if(arr1.length!=arr2.length){
return false;
}
for(int i=0; i< arr1.length;i++){
if(arr1[i]!=arr2[i]){
return false;
}
}
return true;
}
public static void swap(int i,int j,int[] arr){
int a=arr[i];
arr[i]=arr[j];
arr[j]=a;
}
public static void quickSort3(int L,int R,int[] arr){
if(L<R){
int[] position=partition(L,R,arr);
int position_L=position[0];
int position_R=position[1];
quickSort3(L,position_L,arr);
quickSort3(position_R,R,arr);
}
}
public static int[] partition(int L,int R, int[] arr){
int[] point=new int[2];
int pivot_index=L+(int)((R-L)*Math.random());
int pivot=arr[pivot_index];
int point_L=L;
int point_R=R;
int i=L;
while(i<=point_R){
if(arr[i]>pivot){
swap(i,point_R,arr);
point_R--;
}else if(arr[i]<pivot){
swap(i,point_L,arr);
point_L++;
i++;
}else{
i++;
}
}
point[0]=point_L-1;
point[1]=point_R+1;
return point;
}
}
8.堆排序
先把一个数组整体变成大根堆;把位置0和最后一个位置的数进行交换,然后heapsize–,也就是找到了最大值;重复进行heapify。
package class01;
import java.util.Arrays;
public class HeapSort {
public static void main(String[] args) {
int maxSize=10;
int maxVaule=100;
int times=100;
for(int i=0;i<times;i++){
System.out.println(i+1);
int[] arr1=getRandomArray(maxSize,maxVaule);
int[] arr2=copyArray(arr1);
heapSort(arr1);
Arrays.sort(arr2);
if(isEqual(arr1,arr2)){
System.out.println("Successful!");
}else{
printArray(arr1);
System.out.println("???????");
printArray(arr2);
System.out.println("Unsuccessful!");
break;
}
}
}
//打印数组
public static void printArray(int[] arr){
for(int i=0; i<arr.length;i++){
System.out.println(arr[i]);
}
}
public static int[] getRandomArray(int maxSize, int maxValue){
int[] arr=new int[(int)((maxSize+1)*Math.random())];
for(int i=0;i<arr.length;i++){
arr[i]=(int)((maxValue+1)*Math.random())-(int)(maxValue*Math.random());
}
return arr;
}
public static int[] copyArray(int[] arr){
if(arr==null){
return null;
}
int[] arr1=new int[arr.length];
for(int i=0;i<arr.length;i++){
arr1[i]=arr[i];
}
return arr1;
}
public static boolean isEqual(int[] arr1,int[] arr2){
if((arr1==null && arr2!=null)|| (arr2==null && arr1!=null)){
return false;
}
if(arr1.length!=arr2.length){
return false;
}
for(int i=0; i< arr1.length;i++){
if(arr1[i]!=arr2[i]){
return false;
}
}
return true;
}
public static void swap(int i,int j,int[] arr){
int a=arr[i];
arr[i]=arr[j];
arr[j]=a;
}
public static void heapSort(int[] arr){
for(int i=1;i<arr.length;i++){
heapInsert(arr,i);//先排成一个大根堆
}
for(int i=0;i< arr.length-1;i++){
swap(0,arr.length-1-i,arr);
heapify(arr,0,arr.length-2-i);
}
}
//在堆中插入一个新的元素,需要判断该元素与父节点之间的大小关系进行适当的调整,保证当前数据结构是一个最大堆
public static void heapInsert(int[] arr,int index){
int parent=(index-1)/2;
while(arr[index]>arr[parent]){
swap(index,parent,arr);
index=parent;
parent=(index-1)/2;
}
}
//删除一个节点的过程是将队尾元素与要删除的节点进行交换,同时减少堆的大小,遮盖被交换出去数据的存在
//原来的队尾元素插入到新的位置后,需要进行一次自上而下的调整,重新构建最大堆
public static void heapify(int[] arr,int index,int heapSize){
int left=2*index+1;
while(left<=heapSize){
//比较左右子节点之间的最大值
int largest;
//注意是<=
if(left+1<=heapSize){
largest=arr[left]>arr[left+1]?left:(left+1);
}else{
largest=left;
}
largest=arr[largest]>arr[index]?largest:index;
if(largest==index){
break;
}else{
swap(largest,index,arr);
index=largest;
left=2*index+1;
}
}
}
}