001 |
/** |
002 |
* |
003 |
*/ |
004 |
package sortAlgorithm; |
005 |
006 |
import java.io.File; |
007 |
import java.io.IOException; |
008 |
import java.sql.Time; |
009 |
import java.util.Random; |
010 |
011 |
/** |
012 |
* @author sky |
013 |
* 该类给出各种排序算法 |
014 |
* |
015 |
*/ |
016 |
017 |
public class sort{ |
018 |
private static Integer[] elem(int n){ |
019 |
int N=n; |
020 |
Random random=new Random(); |
021 |
Integer elem[]=new Integer[N]; |
022 |
for (int i=0;i<N;i++){ |
023 |
elem[i]=random.nextInt(1000); |
024 |
} |
025 |
return elem; |
026 |
} |
027 |
public static void main (String Args[]) throws InterruptedException{ |
028 |
int n=30000; |
029 |
Integer elem[]=elem(n); |
030 |
long start,end; |
031 |
|
032 |
class sort0 extends Thread{ |
033 |
Integer elem[]; |
034 |
int n; |
035 |
sort0(Integer elem[],int n){ |
036 |
this.elem=elem; |
037 |
this.n=n; |
038 |
} |
039 |
public void run(){ |
040 |
System.out.println("线程启动"); |
041 |
straightInsertSort(elem,n); |
042 |
} |
043 |
} |
044 |
|
045 |
elem=elem(n); |
046 |
start=System.currentTimeMillis(); |
047 |
sort0 s1=new sort0(elem,n); |
048 |
|
049 |
elem=elem(n); |
050 |
sort0 s2=new sort0(elem,n); |
051 |
elem=elem(n); |
052 |
sort0 s3=new sort0(elem,n); |
053 |
elem=elem(n); |
054 |
sort0 s4=new sort0(elem,n); |
055 |
elem=elem(n); |
056 |
sort0 s5=new sort0(elem,n); |
057 |
s1.start(); |
058 |
s2.start(); |
059 |
s3.start(); |
060 |
s4.start(); |
061 |
s5.start(); |
062 |
s2.join(); |
063 |
s1.join(); |
064 |
s3.join(); |
065 |
s4.join(); |
066 |
s5.join(); |
067 |
System.out.println("多线程简单插入排序："); |
068 |
end=System.currentTimeMillis(); |
069 |
|
070 |
System.out.println(end-start); |
071 |
|
072 |
elem=elem(n); |
073 |
start=System.currentTimeMillis(); |
074 |
straightInsertSort(elem,n); |
075 |
end=System.currentTimeMillis(); |
076 |
System.out.println("简单插入排序："); |
077 |
System.out.println(end-start); |
078 |
|
079 |
elem=elem(n); |
080 |
start=System.currentTimeMillis(); |
081 |
shellSort(elem,n); |
082 |
end=System.currentTimeMillis(); |
083 |
System.out.println("希尔排序："); |
084 |
System.out.println(end-start); |
085 |
|
086 |
elem=elem(n); |
087 |
start=System.currentTimeMillis(); |
088 |
bubbleSort(elem,n); |
089 |
end=System.currentTimeMillis(); |
090 |
System.out.println("冒泡排序："); |
091 |
System.out.println(end-start); |
092 |
|
093 |
/* |
094 |
elem=elem(n); |
095 |
start=System.currentTimeMillis(); |
096 |
quickSort(elem,n); |
097 |
end=System.currentTimeMillis(); |
098 |
System.out.println("快速排序："); |
099 |
System.out.println(end-start);*/ |
100 |
|
101 |
elem=elem(n); |
102 |
start=System.currentTimeMillis(); |
103 |
simpleSelectionSort(elem,n); |
104 |
end=System.currentTimeMillis(); |
105 |
System.out.println("简单选择排序："); |
106 |
System.out.println(end-start); |
107 |
|
108 |
elem=elem(n); |
109 |
start=System.currentTimeMillis(); |
110 |
heapSort(elem,n); |
111 |
end=System.currentTimeMillis(); |
112 |
System.out.println("堆排序："); |
113 |
System.out.println(end-start); |
114 |
|
115 |
elem=elem(n); |
116 |
start=System.currentTimeMillis(); |
117 |
mergeSort(elem,n); |
118 |
end=System.currentTimeMillis(); |
119 |
System.out.println("归并排序："); |
120 |
System.out.println(end-start); |
121 |
} |
122 |
|
123 |
//显示排序结果 |
124 |
public static <T extends Comparable<? super T>> void show(T[] elem,int n){ |
125 |
for (int i=0;i<n;i++){ |
126 |
System.out.print(elem[i]); |
127 |
System.out.print(' '); |
128 |
} |
129 |
System.out.println(); |
130 |
} |
131 |
//交换元素 |
132 |
private static <T extends Comparable<? super T>> void swap(T[] elem,int i,int j){ |
133 |
T tmp=elem[i]; |
134 |
elem[i]=elem[j]; |
135 |
elem[j]=tmp; |
136 |
} |
137 |
//直接插入排序法,复杂度为O(n^2) |
138 |
public static <T extends Comparable<? super T>> void straightInsertSort (T elem[],intn){ |
139 |
for (int i=1;i<n;i++){ |
140 |
T e=elem[i]; |
141 |
int j; |
142 |
for (j=i-1;j>=0 && e.compareTo(elem[j])<0;j--){ |
143 |
elem[j+1]=elem[j]; |
144 |
} |
145 |
elem[j+1]=e; |
146 |
} |
147 |
} |
148 |
//shell插入排序算法,复杂度为O(n^1.5) |
149 |
private static <T extends Comparable<? super T>> void shellInsertHelp(T elem[],intn,int incr){ |
150 |
for (int i=incr;i<n;i++){ |
151 |
T e=elem[i]; |
152 |
int j=i-incr; |
153 |
for (;j>=0 && e.compareTo(elem[j])<0;j=j-incr){ |
154 |
elem[j+incr]=elem[j]; |
155 |
} |
156 |
elem[j+incr]=e; |
157 |
|
158 |
} |
159 |
} |
160 |
public static <T extends Comparable<? super T>> void shellSort(T elem[],int n ){ |
161 |
for (int incr=n/2;incr>0;incr=incr/2){ |
162 |
shellInsertHelp(elem,n,incr); |
163 |
} |
164 |
} |
165 |
//冒泡排序算法，时间复杂度为O(n^2) |
166 |
public static <T extends Comparable<? super T>> void bubbleSort(T elem[],int n){ |
167 |
for (int i=n-1;i>0;i--){ |
168 |
for (int j=0;j<i;j++){ |
169 |
if (elem[j].compareTo(elem[i])>0){ |
170 |
swap(elem,i,j); |
171 |
} |
172 |
} |
173 |
} |
174 |
} |
175 |
//快速排序算法，时间复杂度为O(n*log(n)) |
176 |
private static <T extends Comparable<? super T>> int partition(T elem[],int low,inthigh){ |
177 |
while (low<high){ |
178 |
for (;elem[high].compareTo(elem[low])>=0 && low<high;high--); |
179 |
swap(elem,high,low); |
180 |
for (;elem[high].compareTo(elem[low])>=0 && low<high;low++); |
181 |
swap(elem,high,low); |
182 |
} |
183 |
return low; |
184 |
} |
185 |
private static <T extends Comparable<? super T>> void quickSortHelp(T elem[],intlow,int high){ |
186 |
if (low<high){ |
187 |
int pivot=partition(elem,low,high); |
188 |
quickSortHelp(elem,low,pivot-1); |
189 |
quickSortHelp(elem,pivot+1,high); |
190 |
} |
191 |
} |
192 |
public static <T extends Comparable<? super T>> void quickSort(T elem[],int n){ |
193 |
quickSortHelp(elem,0,n-1); |
194 |
} |
195 |
//简单选择排序算法，时间复杂度为O(n^2) |
196 |
public static <T extends Comparable<? super T>> void simpleSelectionSort(T elem[],intn){ |
197 |
for (int i=0;i<n-1;i++){ |
198 |
int lowIdx=i; |
199 |
for (int j=i+1;j<n;j++){ |
200 |
if (elem[lowIdx].compareTo(elem[j])>0) |
201 |
lowIdx=j; |
202 |
} |
203 |
swap(elem,lowIdx,i); |
204 |
} |
205 |
} |
206 |
//堆排序，时间复杂度为O(n*log(n)) |
207 |
private static <T extends Comparable<? super T>> void heapAdjust(T elem[],int low,inthigh){ |
208 |
for (int i=low,lhs=2*i+1 ;lhs<=high;lhs=2*i+1){ |
209 |
if (lhs<high && elem[lhs].compareTo(elem[lhs+1])<0)lhs++; |
210 |
if (elem[i].compareTo(elem[lhs])<0){ |
211 |
swap(elem,i,lhs); |
212 |
i=lhs; |
213 |
}else break; |
214 |
} |
215 |
} |
216 |
public static <T extends Comparable<? super T>> void heapSort(T elem[],int n){ |
217 |
//初始化堆 |
218 |
for (int i=(n-2)/2;i>=0;i--){ |
219 |
heapAdjust(elem,i,n-1); |
220 |
} |
221 |
swap(elem,0,n-1); |
222 |
//排序 |
223 |
for (int i=n-2;i>0;--i){ |
224 |
heapAdjust(elem,0,i); |
225 |
swap(elem,0,i); |
226 |
} |
227 |
} |
228 |
//归并排序算法，时间复杂度为O(n*log(n)) |
229 |
private static <T extends Comparable<? super T>> void simpleMerge(T elem[],T tmpElem[],int low ,int mid, int high){ |
230 |
int i=low,j=mid+1,k=low; |
231 |
for (;i<=mid && j<=high;k++){ |
232 |
if (elem[i].compareTo(elem[j])<=0) |
233 |
tmpElem[k]=elem[i++]; |
234 |
else |
235 |
tmpElem[k]=elem[j++]; |
236 |
} |
237 |
for (;i<=mid;i++){ |
238 |
tmpElem[k++]=elem[i]; |
239 |
} |
240 |
for (;j<=high;j++){ |
241 |
tmpElem[k++]=elem[j]; |
242 |
} |
243 |
|
244 |
for (;low<=high;low++){ |
245 |
elem[low]=tmpElem[low]; |
246 |
} |
247 |
} |
248 |
private static <T extends Comparable<? super T>> void mergeHelp(T elem[],T tmpElem[],int low ,int high){ |
249 |
if (low < high){ |
250 |
int mid=(low+high)/2; |
251 |
mergeHelp(elem,tmpElem,low,mid); |
252 |
mergeHelp(elem,tmpElem,mid+1,high); |
253 |
simpleMerge(elem,tmpElem,low,mid,high); |
254 |
} |
255 |
} |
256 |
public static <T extends Comparable<? super T>> void mergeSort(T elem[],int n){ |
257 |
T[] tmpElem=(T[])new Comparable[n]; |
258 |
mergeHelp(elem,tmpElem,0,n-1); |
259 |
} |
260 |
} |