排序(希尔排序 堆排序 归并 排序, 快速排序)
-------------------学习笔记
希尔排序:
int temp;
int gab = num.length;
do{
gab = gab / 3 + 1;
for (int i=gab; i <num.length; i++){
temp = num[i];
int j;
for (j=i-gab; j>=0 && num[j] > temp; j-=gab){
num[j+gab] = num[j];
}
num[j+gab] = temp;
}
}while (gab > 1);
堆排序:
public static void main(String[] args) {
int num[] = new int[]{9,8,7,6,5,4,3,2,1};
int length = num.length;
for (int i=length/2; i>=0; i--){
HeapAdjust(num, i, length);
}
for (int i=length-1; i>0; i--){
swap(num, 0, i);
HeapAdjust(num, 0, i);
}
//for (int num1 : num)
//System.out.println(num1);
}
private static void swap(int num[], int x, int y){
int temp = num[x];
num[x] = num[y];
num[y] = temp;
}
private static void HeapAdjust(int num[], int s, int m){
int temp = num[s];
for (int j=2*s+1; j<m; j=2*s+1){
if (j <m-1 && num[j] < num[j+1])
j++;
if (num[j] < temp)
break;
num[s] = num[j];
s = j;
}
num[s] = temp;
}
归并排序:
public class mergeSort {
int[] arr;
private void merge(int low, int mid, int high){
int[] temp = new int[high - low + 1];
int i = low, j = mid+1;
int k = 0;
while (i <= mid && j <= high){
if (arr[i] < arr[j]){
temp[k++] = arr[i++];
}else{
temp[k++] = arr[j++];
}
}
while (i <= mid){
temp[k++] = arr[i++];
}
while (j <= high){
temp[k++] = arr[j++];
}
for (i=0; i<=high-low; i++){
arr[i+low] = temp[i];
}
}
private void sort(int low, int high){
int mid = (low + high) / 2;
if (low < high){
sort(low, mid);
sort(mid+1, high);
merge(low, mid, high);
}
return;
}
public mergeSort(int[] arr1){
arr = arr1;
sort(0, arr.length-1);
}
}
快速排序:
public class QuickSort {
private int[] arr;
private void swap(int x, int y){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
private void QuickSortRecursive(int start, int end){
if (start >= end)
return;
int pivotkey = arr[end];
int left = start;
int right = end - 1;
while (left < right){
while(arr[left] < pivotkey && left < right)
left++;
while(arr[right] >= pivotkey && left < right)
right--;
swap(left, right);
}
if (arr[left] >= pivotkey)
swap(left, end);
else
left++;
QuickSortRecursive(start, left-1);
QuickSortRecursive(left+1, end);
}
public void sort(){
QuickSortRecursive( 0, arr.length -1);
}
public QuickSort(int[] arr1){
arr = arr1;
}
}
优化:
public class QuickSort {
private int[] arr;
private final int maxSize = 7;
private void swap(int x, int y){
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
private void median(int start, int end ){
int mid = (start - end) /2 + end;
if (arr[start] > arr[end]){
swap(start, end);
if (arr[start] > arr[mid])
swap(start, mid);
if (arr[mid] < arr[end])
swap(mid, end);
}
}
private void insertSort(int start, int end){
int temp, j;
for (int i=start+1; i<=end; i++){
temp = arr[i];
for (j =i;j>start && arr[j-1] > temp; j--){
arr[j] = arr[j-1];
}
arr[j] = temp;
}
}
private void QuickSortRecursive(int start, int end){
if (maxSize <(start - end)){
median(start, end);
int pivotkey = arr[end];
int left = start;
int right = end - 1;
while (left < right){
while(arr[left] < pivotkey && left < right)
left++;
while(arr[right] >= pivotkey && left < right)
right--;
swap(left, right);
}
if (arr[left] >= pivotkey)
swap(left, end);
else
left++;
QuickSortRecursive(start, left-1);
QuickSortRecursive(left+1, end);
}
else
insertSort(start, end);
}
public QuickSort(int[] arr1){
arr = arr1;
QuickSortRecursive( 0, arr.length -1);
}
}