Java排序算法
初始化数组
public static Integer[ ] getList ( int size) {
Integer[ ] demoArr = new Integer [ size] ;
Random random = new Random ( ) ;
for ( int i = 0 ; i < size; i++ ) {
demoArr[ i] = random. nextInt ( size) ;
}
return demoArr;
}
交换函数
public static void swapElement ( int [ ] arr, int i, int j) {
int swapEle = arr[ j] ;
arr[ j] = arr[ i] ;
arr[ i] = swapEle;
}
插入排序
Integer[ ] demoArr = getList ( 10 ) ;
for ( int i = 0 ; i < demoArr. length; i++ ) {
for ( int j = i; j > 0 ; j-- ) {
if ( demoArr[ j] < demoArr[ j - 1 ] ) {
Integer demo = demoArr[ j - 1 ] ;
demoArr[ j - 1 ] = demoArr[ j] ;
demoArr[ j] = demo;
}
}
}
for ( Integer demo : demoArr) {
System. out. println ( demo) ;
}
冒泡排序
int [ ] demoArr = getList ( 10 ) ;
for ( int i = 0 ; i < demoArr. length; i++ ) {
for ( int j = 0 ; j < demoArr. length - i - 1 ; j++ ) {
if ( demoArr[ j] < demoArr[ j + 1 ] ) {
int swapEle = demoArr[ j + 1 ] ;
demoArr[ j + 1 ] = demoArr[ j] ;
demoArr[ j] = swapEle;
}
}
}
for ( Integer demo : demoArr) {
System. out. println ( demo) ;
}
堆排序
堆排序(heap_sort):利用堆这种数据结构所设计的一种排序算法。
堆积是一个近似二叉树的结构,并同时满足堆积的性质:子节点的键值或索引总是小于(或者大于)它的父节点。
堆排序的两种方式:
1. 大顶堆:每个节点的值都大于或等于其子节点的值,在堆排序算法中用于升序排列。
2. 小顶堆:每个节点的值都小于或或等于其子节点的值,在堆排序算法中用于降序排列。
public static void main ( String[ ] args) {
int [ ] demoArr = getArray ( 10 ) ;
for ( int i : demoArr) {
System. out. print ( i + " " ) ;
}
System. out. println ( ) ;
int length = demoArr. length;
buildMaxHeap ( demoArr, length) ;
for ( int i = length - 1 ; i > 0 ; i-- ) {
swapElement ( demoArr, 0 , i) ;
length -- ;
heapify ( demoArr, 0 , length) ;
}
for ( int i : demoArr) {
System. out. print ( i + " " ) ;
}
}
private static void buildMaxHeap ( int [ ] arr, int len) {
for ( int i = ( int ) Math. floor ( len/ 2 ) ; i >= 0 ; i-- ) {
heapify ( arr, i, len) ;
}
}
private static void heapify ( int [ ] arr, int i, int len) {
int left = i * 2 + 1 ;
int right = i * 2 + 2 ;
int largest = i;
if ( left < len && arr[ left] > arr[ largest] ) {
System. out. println ( "i. " + i + ", left. " + left + ", value. " + arr[ left] ) ;
largest = left;
}
if ( right < len && arr[ right] > arr[ largest] ) {
System. out. println ( "i. " + i + ", right. " + right + ", value. " + arr[ right] ) ;
largest = right;
}
if ( largest != i) {
System. out. println ( "largest. " + largest) ;
swapElement ( arr, i, largest) ;
heapify ( arr, largest, len) ;
}
}
快速排序
基本信息
快速排序由于排序效率在同为O(N*logN)的几种排序方法中效率较高,因此经常被采用,
在加上快速排序思想---<分治法>也确实实用,因此很多软件公司的笔试面试,
包括想腾讯,微软等知名IT公司都喜欢考,还有大大小小的程序方面的考是如软考,考研中也常常出现快速排序的身影。
快速排序是C.R.A.Hoare与1962年提出的一种划分交换排序。它采用了一种分治的策略,通常称其为分治法(Divide-and-ConquerMethod)
基本思想
1. 先从数列中取出一个数作为基准数。
2. 分区过程,将比这个数大的数全放到它的右边,小于或等于它的数全放到他的左边。
3. 在对左右区间重复第二步,直到各区间只有一个数。
public static void quickSort ( int [ ] arr, int startIndex, int endIndex) {
if ( startIndex < endIndex) {
int start = startIndex;
int end = endIndex;
int baseVal = arr[ startIndex] ;
while ( start != end) {
while ( start < end && baseVal < arr[ end] ) {
end-- ;
}
while ( start < end && baseVal >= arr[ start] ) {
start++ ;
}
if ( start < end) {
int swapEle = arr[ start] ;
arr[ start] = arr[ end] ;
arr[ end] = swapEle;
}
}
int swapEle = arr[ start] ;
arr[ start] = arr[ startIndex] ;
arr[ startIndex] = swapEle;
quickSort ( arr, startIndex, start - 1 ) ;
quickSort ( arr, start + 1 , endIndex) ;
}
}