Java排序8大基本算法

Java排序8大基本算法

本文由网络资料整理转载而来，如有问题，欢迎指正！

算法分类

• 插入排序（直接插入排序、希尔排序）
• 交换排序（冒泡排序、快速排序）
• 选择排序（简单选择排序、堆排序）
• 归并排序
• 基数排序

时间复杂度

排序方法	平均情况	最好情况	最坏情况	辅助空间	稳定性
冒泡排序	O(n2)	O(n)	O(n2)	O(1)	稳定
简单选择排序	O(n2)	O(n2)	O(n2)	O(1)	不稳定
直接插入排序	O(n2)	O(n)	O(n2)	O(1)	稳定
希尔排序	O(nlog2n)~O(n2)	O(n1.3)	O(n2)	O(1)	不稳定
堆排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(1)	不稳定
快速排序	O(nlog2n)	O(nlog2n)	O(n2)	O(log2n)~O(n)	不稳定
归并排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(n)	稳定
基数排序	O(d(r+n))	O(d(n+rd))	O(d(r+n))	O(rd+n)	稳定

注：基数排序的复杂度中，r代表关键字的基数，d代表长度，n代表关键字的个数

排序算法

公共交换方法
void swap(int[] a, int i, int j) {
    int temp =a[i];
    a[i] = a[j];
    a[j] = temp;
}

冒泡排序

void bubbleSort(int[] data) {
    int i，j;
    for(i = 0; i < data.length - 1; i++) {
        for(j = data.length - 2; j >= i; j--) {
            if (data[j] > data[j+1]) {
                swap(data, j, j + 1);
            }
        }
    }
}

改进版

void bubbleSort(int[] data) {
    int i，j;
    boolean flag = true;
    for(i = 0; i < data.length - 1 && flag; i++) {
        flag = false;
        for(j = data.length - 2; j >= i; j--) {
            if (data[j] > data[j+1]) {
                swap(data, j, j + 1);
                flag = true;
            }
        }
    }
}

简单选择排序

交换次数减少
void simpleSelectSort(int[] data) {
    int i，j，min;
    for(i = 0; i < data.length - 1; i++) {
        min = i;
        for(j = i + 1; j <= data.length - 1; j++) {
            if (data[min] > data[j]) {
                min = j;
            }
        }
        if(i != min) {
            swap(data, i, min);
        }
    }
}

直接插入排序

void insertSort(int[] data) {
    int i，j，temp;
    for(i = 1; i < data.length; i++) {
        if(data[i] < data[i-1]) {
            temp = data[i];
            for(j = i - 1; j >= 0 && temp < data[j]; j--) {
                data[j+1] = data[j];
            }
            data[j+1] = temp;
        }
    }
}

希尔排序

void shellSort(int[] data) {
    int i，j，k，temp;
    int d = data.length;
    while(true) {
        d = d / 2;
        for(k = 0; k < d; k++) {
            for(i = k + d; i < data.length; i = i + d) {
                temp = data[i];
                for(j = i - d; j >= 0 && temp < data[j]; j = j - d) {
                    data[j+d] = data[j];
                }
                data[j+d] = temp;
            }
        }
        if (d == 1) {
            break;
        }
    }
}

堆排序

void heapSort(int[] data) {
    int i;
    for(i = data.length / 2; i >= 0; i--) {
        heapAdjust(data, i, data.length - 1);
    }
    for(i = data.length - 1; i > 0; i--) {
        swap(data, 0, i);
        heapAdjust(data, 0, i - 1);
    }
}

void heapAdjust(int[] data, int index, int max) {
    int j，temp;
    temp = data[index];
    for(j = index * 2 + 1; j <= max; j = j * 2 + 1) {
        if (j < max && data[j] < data[j+1]) {
            j++;
        }
        if (temp >= data[j]) {
            break;
        }
        data[index] = data[j];
        index = j;
    }
    data[index] = temp;
}

快速排序

void quickSort(int[] data) {
    _quickSort(data, 0, data.length - 1);
}

void _quickSort(int[] data, int low, int high) {
    if (low < high) {
        int middle = getMiddle(data, low, high);
        _quickSort(data, 0, middle - 1);
        _quickSort(data, middle + 1, high);
    }
}

int getMiddle(int[] data, int low, int high) {
    int middleKey = data[low];
    while(low < high) {
        while(low < high && data[high] >= middleKey) {
            high--;
        }
        data[low] = data[high];
        while(low < high && data[low] <= middleKey) {
            low++;
        }
        data[high] = data[low];
    }
    data[low] = middleKey;
    return low;
}

归并排序

void mergingSort(int[] data) {
    mergeSort(data, 0, data.length);
}
void mergeSort(int[] data, int left, int right) {
    if (left < right) {
        int center = (left + right) / 2;
        mergeSort(data, left, center);
        mergeSort(data, center + 1, right);
        merge(data, left, center, right);
    }
}
void merge(int[] data, int left, int center, int right) {
    int[] tempData = new int[data.length];
    int mid = center + 1;
    int tempIndex = left;
    int copyIndex = left;
    while(left <= center && mid <= right) {
        if (data[left] <= data[mid]) {
            tempData[tempIndex++] = data[left++];
        } else {
            tempData[tempIndex++] = data[mid++];
        }
    }
    while(left <= center) {
        tempData[tempIndex++] = data[left++];
    }
    while(mid <= right) {
        tempData[tempIndex++] = data[mid++];
    }
    while (copyIndex <= right) {
        data[copyIndex] = tempData[copyIndex++];
    }
}

基数排序

void radixSort(int[] data) {
    int max = data[0];
    int i, j;
    //获取最大的数
    for(i = 1; i < data.length; i++) {
        if (max < data[i]) {
            max = data[i];
        }
    }
    // 获取最大数是几位数
    int digits = 0;
    while(max > 0) {
        max = max / 10;
        digits++;
    }
    List<ArrayList> queue = new ArrayList<ArrayList>();
    ArrayList<Integer> queueData;
    for(i = 0； i < 10; i++) {
        queueData = new ArrayList<Integer>();
        queue.add(queueData);
    }
    for(i = 0; i < time; i++) {
        for (j = 0; j < data.length; j++) {
                int number = data[j] % (int)Math.pow(10, i+1) / (int)Math.pow(10, i);
                queueData = queue.get(number);
                queueData.add(data[j]);
                queue.set(number, queueData);
        }
        int count = 0;
        for(int k = 0; k < 10; k++) {
            queueData = queue.get(k);
            while(queueData.size() > 0) {
                data[count++] = queueData.get(0);
                queueData.remove(0);
            }
        }
    }
}