各种排序算法

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

}