http://www.cnblogs.com/eniac12/p/5329396.html
1,交换排序
1)冒泡排序
尽管是最容易理解的排序算法之一,但他对于少数元素之外的数列排序是很没有效率的
//冒泡排揎
private static void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
2)快速排序
//快速排序
private static void quickSort(int[] arr, int left, int right) {
int i, j, t, temp;
if (left > right) {
return;
}
temp = arr[left];//temp中存放的是基准数
i = left;
j = right;
while (i != j) {
//先从有病开始找
while (arr[j] >= temp && i < j) {
j--;
}
//在找左边
while (arr[i] <= temp && i < j) {
i++;
}
//交换两个数在数组中的位置
if (i < j) {
t = arr[i];
arr[i] = arr[j];
arr[j] = t;
}
}
//最终将基数归位
arr[left] = arr[i];
arr[i] = temp;
quickSort(arr, left, i - 1);//继续处理左边的
quickSort(arr, i + 1, right);//继续处理右边的
}
2,插入排序
1)插入排序
//插入排序
private static void insertionSort(int[] arr){
int preIndex,current;
for (int i = 1; i < arr.length; i++){
preIndex = i - 1;
current = i;
while (preIndex >= 0 && arr[preIndex] > current){
arr[preIndex + 1] = arr[preIndex];
preIndex --;
}
arr[preIndex + 1] = current;
}
}
2)希尔排序
//希尔排序
private static void shellSort(int[] arr) {
int gap = (int) Math.ceil(arr.length / 2d); //对浮点数向上取整
while (gap > 0){
for (int i = 0; i < arr.length; i++){
int j = i;
int temp = arr[i];
while (j >= gap && arr[j - gap] > temp){
arr[j] = arr[j-gap];
j = j - gap;
}
arr[j] = temp;
}
gap = (int)Math.floor(0.5 + gap / 2.2); //对浮点数向下取整
}
}
3,选择排序
1)选择排序
//选择排序
private static void selectionSort(int[] arr) {
int minIndex, temp;
for (int i = 0; i < arr.length - 1; i++) {
minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[minIndex]){ //寻找最小的数
minIndex = j; //将最小的数索引保存
}
}
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
2)堆排序
//堆排序
private static void heapSort(int[] arr){
buildMaxHeap(arr); //建立大根堆
for (int i = arr.length - 1; i >= 1; i--){
int max = arr[0];
arr[0] = arr[i];
arr[i] = max;
maxHeapity(arr,0,i - 1);
}
}
private static void buildMaxHeap(int[] arr){
for (int i = (arr.length / 2) - 1; i > 0; i--){
maxHeapity(arr,i,arr.length - 1);
}
}
private static void maxHeapity(int[] arr,int root,int bottom){
int rootValue = arr[root];
int maxChild = root * 2 + 1;//start from left child
while (maxChild <= bottom){
if (maxChild < bottom){
if (arr[maxChild] < arr[maxChild + 1]){
maxChild = maxChild + 1;
}
}
if (rootValue < arr[maxChild]){
arr[root] = arr[maxChild];
root = maxChild;
maxChild = root * 2 + 1;
} else {
maxChild = bottom + 1;
}
arr[root] = rootValue;
}
}