各排序算法java实现

Posted 2021-02-18 藤原拓海

 

  1 package SortingAlgorithm;
  2 
  3 import java.util.Arrays;
  4 
  5 public class sortalgorithm {
  6     public static void main(String[] args) {
  7         int[] array = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
  8 //        bubbleSort(array);
  9 //        selectionSort(array);
 10 //        insertionSort(array);
 11 //        mergeSort(array);
 12 //        quickSort(array);
 13         countSort(array);
 14         System.out.print(Arrays.toString(array));
 15     }
 16 //    1.冒泡排序
 17 //    最佳情况：T(n) = O(n) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)
 18     public static void bubbleSort(int[] array){
 19         if(array==null||array.length<=1)return;
 20         // 外层循环控制比较轮数i
 21         for(int i=0;i<=array.length-1;i++){
 22             // 内层循环控制每一轮比较次数，每进行一轮排序都会找出一个较大值
 23             // (array.length - 1)防止索引越界，(array.length - 1 - i)减少比较次数
 24             for(int j=0;j<array.length-1-i;j++){
 25                 if(array[j]>array[j+1]){
 26                     int temp = array[j];
 27                     array[j]=array[j+1];
 28                     array[j+1]=temp;
 29                 }
 30             }
 31         }
 32     }
 33 //     2.选择排序
 34 //     最佳情况：T(n) = O(n2) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)
 35 //    它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
 36 //    然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
 37     public static void selectionSort(int[] array) {
 38         if(array==null||array.length<=1) return;
 39         for(int i=0;i<array.length-1;i++){
 40             int minindex=i;
 41             for(int j=i+1;j<array.length;j++){
 42                 if(array[j]<array[minindex]){
 43                     minindex=j;
 44                 }
 45             }
 46             if(minindex!=i){
 47                 swap(array,minindex,i);
 48             }
 49         }
 50     }
 51     private static void swap(int[] array, int a, int b) {
 52         int temp = array[a];
 53         array[a] = array[b];
 54         array[b] = temp;
 55     }
 56 //    3.插入排序
 57 //    最佳情况：T(n) = O(n) 最坏情况：T(n) = O(n2) 平均情况：T(n) = O(n2)
 58 //    它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
 59     public static void insertionSort(int[] array) {
 60         if(array==null||array.length<=1)return;
 61         for(int i=1;i<array.length;i++){
 62             int insertNum = array[i];
 63             int j=i-1;
 64             while(j>=0&&array[j]>insertNum){
 65                 array[j+1]=array[j];
 66                 j--;
 67             }
 68             array[j+1]=insertNum;
 69         }
 70     }
 71 //    4.归并排序
 72 //    最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(nlogn) 平均情况：T(n) = O(nlogn)
 73     public static void mergeSort(int[] array) {
 74         if(array==null||array.length<=1)return;
 75         sort(array,0,array.length-1);
 76     }
 77     public static void sort(int[] array,int left,int right){
 78         if(left==right){return;}
 79         int mid = (left+right)>>1;
 80         sort(array,left,mid);
 81         sort(array,mid+1,right);
 82         merge(array,left,mid,right);
 83     }
 84     public static void merge(int[] array,int left,int mid,int right){
 85         int[] temp = new int[right-left+1];
 86         int p1 = left;
 87         int p2 = mid+1;
 88         int i=0;
 89         while(p1<=mid&&p2<=right){
 90             temp[i++]=array[p1]<array[p2]?array[p1++]:array[p2++];
 91         }
 92         while(p1<=mid) temp[i++]=array[p1++];
 93         while(p2<=right) temp[i++]=array[p2++];
 94         for(i=0;i<temp.length;i++){
 95             array[left+i]=temp[i];
 96         }
 97     }
 98 //    5.快速排序
 99 //    最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(nlogn)
100 //    从数列中挑出一个元素，称为 “基准”（pivot）；
101 //重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
102 // 在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
103 //递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
104     public static void quickSort(int[] array) {
105         quickSort(array,0,array.length-1);
106     }
107     public static void quickSort(int[] array,int left,int right){
108         if(array==null||left>=right||array.length<=1)return;
109         int mid = partition(array,left,right);
110         quickSort(array,left,mid);
111         quickSort(array,mid+1,right);
112     }
113     private static int partition(int[] array, int left, int right){
114         int temp = array[left];
115         while(left<right){
116             while(temp<=array[right]&&left<right){
117                 right--;
118             }
119             if(left<right){
120                 array[left]=array[right];
121                 left++;
122             }
123             while(temp>=array[left]&&left<right){
124                 left++;
125             }
126             if(left<right){
127                 array[right]=array[left];
128                 right--;
129             }
130         }
131         array[left]=temp;
132         return left;
133     }
134 //******************************************************************
135 //    6.计数排序
136     public static void countSort(int[] array) {
137         if(array==null||array.length<=1) return;
138         int max = array[0];
139         int min =array[0];
140         for(int i=0;i<array.length;i++){
141             if(max<array[i]) max=array[i];
142             if(min>array[i]) min=array[i];
143         }
144         int len = max-min+1;
145         int[] countArray = new int[len];
146         for(int i=0;i<array.length;i++){
147             countArray[array[i]-min]++;
148         }
149         int index=0;
150         for(int i=0;i<countArray.length;i++){
151             for(int j=0;j<countArray[i];j++){
152                 array[index++]=i+min;
153             }
154         }
155     }
156 
157 
158 }