七大排序算法

/**
 * 数组元素交换
 * @param arr
 * @param start
 * @param end
 */
public static void swap(int arr[], int start, int end) {
    
    arr[end] = arr[start] ^ arr[end];
    arr[start] = arr[start] ^ arr[end];
    arr[end] = arr[start] ^ arr[end];
}

1.
/**
 * 选择排序
 * @param arr
 */
public static void selectSort(int arr[]) {
    
    //定义当前最小元素下标
    int minIndex = 0;
    for (int i = 0; i < arr.length; i++) {
        
        minIndex = i;
        
        for (int j = i + 1; j < arr.length; j++) {
            
            //如果当前下标元素值大于后面的元素值把最小值下标赋值给当前下标
            if (arr[minIndex] > arr[j]) {
                minIndex = j;
            }
        }
        
        //当获取到更小值交换元素
        if (minIndex != i) {
            swap(arr, i, minIndex);
        }
    }
}

2.
/**
 * 冒泡排序
 * @param arr
 */
public static void bubbleSort(int arr[]) {
    
    for (int i = 0; i < arr.length; i++) {
        
        for (int j = i+1; j < arr.length; j++) {
            
            //如果后续元素值小于当前元素则交换元素值
            if (arr[i] > arr[j] ) {
                swap(arr, i, j);
            }
        }
    }
}

3.
/**
 * 插入排序
 * @param arr
 */
public static void insertSort(int arr[]) {
    
    for (int i = 1; i < arr.length; i++) {
        
        //当该前部分值有更小的元素则进行排序
        for (int j = i; j > 0; j--) {
            if (arr[j-1] > arr[j]) {
                swap(arr, j-1, j);
            }
        }
    }
}

4.
/**
 * 希尔排序
 * @param arr
 */
public static void shellSort(int arr[]) {
    
    //定义循环次数
    for (int gap = 3; gap > 0; gap--) {
        
        //进行插入排序
        for (int i = 1; i < arr.length; i++) {
            
            for (int j = i; j >= gap; j-=gap) {
                if (arr[j-gap] > arr[j]) {
                    swap(arr, j-gap, j);
                }
            }
        }
    }
}

5.
/**
 * 归并排序
 * @param arr
 */
public static void mergeSort(int arr[]) {
    mergeProcess(arr, 0, arr.length-1);
}

/**
 * 归并过程
 * @param arr
 * @param left
 * @param right
 */
public static void mergeProcess(int arr[], int left, int right) {
    
    if (left == right) {
        return;
    }
    
    int mid = ((right - left) >> 1) + left;
    
    mergeProcess(arr, left, mid);
    mergeProcess(arr, mid+1, right);
    merge(arr,left,mid,right);
}

/**
 * 归并
 * @param arr
 * @param left
 * @param mid
 * @param right
 */
public static void merge(int arr[], int left, int mid, int right) {
    
    int tmp[] = new int[right - left + 1];
    int i = 0;
    int p1 = left;
    int p2 = mid + 1;
    
    while (p1 <= mid && p2 <= right) {
        tmp[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
    }
    
    while (p1 <= mid) {
        tmp[i++] = arr[p1++];
    }
    
    while (p2 <= right) {
        tmp[i++] = arr[p2++];
    }
    
    for (int j = 0; j < tmp.length; j++) {
        arr[left + j] = tmp[j];
    }
}

6.
/**
 * 快速排序
 * @param arr
 * @param left
 * @param right
 */
public static void quickSort(int arr[], int left, int right) {
    
    if (left < right) {
        
        int i = left;
        int j = right;
        int k = arr[i];
        
        while (i < j) {
            
            while (i < j && arr[j] > k ) {
                j--;
            }
            if (i < j) {
                arr[i] = arr[j];
                i++;
            }
            
            while (i < j && arr[i] < k ) {
                i++;
            }
            if (i < j) {
                arr[j] = arr[i];
                j--;
            }
        }
        arr[i] = k;
        
        quickSort(arr, left, i-1);
        quickSort(arr, i+1, right);
    }
}

7.
/**
 * 堆排序
 * @param arr
 */
public static void heapSort(int arr[]) {
    
    for (int i = 0; i < arr.length; i++) {
        buildHeap(arr, i);
    }
    
    int heapSize = arr.length;
    
    swap(arr, 0, --heapSize);
    
    while (heapSize > 0) {
        transferHeap(arr, 0, heapSize);
        swap(arr, 0, --heapSize);
    }
}

public static void buildHeap(int arr[], int index) {
    
    //建立大顶堆
    while (arr[index] > arr[(index-1)/2]) {
        swap(arr, index, (index-1)/2);
        index = (index-1)/2;
    }
}

/**
 * 调堆过程
 * @param arr
 * @param index
 * @param heapSize
 */
public static void transferHeap(int arr[], int index, int heapSize) {
    
    //左子树索引
    int left = index * 2 + 1;

    while (left < heapSize) {
        
        int max = (left + 1 < heapSize) && (arr[left] < arr[left + 1])?left + 1 : left;
        max = arr[index] > arr[max]?index : max;
        
        if (max == index) {
            break;
        }
        swap(arr, max, index);
        index = max;
        left = index * 2 + 1;
    }
}