java实现各种排序算法

[Java]代码
view sourceprint?
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[],int n){

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[],int n,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,int high){

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[],int low,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[],int n){

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,int high){

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 }