java排序算法(冒泡，插入，选择，快速，堆，归并，希尔，基数)
2012-08-06 20:39
615 查看
import java.util.Arrays;
import java.util.LinkedList;
/**
*
*
* 各种排序: 冒泡，插入，选择，快速，堆，归并，希尔，基数
*/
public class Sorts {
//1. 冒泡：
//时间复杂度:n(n-1)/2=O(n^2)
//1. 第一次把最大的放后面
//2. 把最大的放后面。。。
//3. 。。。
static void BubbleSort(int arr[], int start, int end){
int len = end - start + 1;
for(int i = 0; i < len; i++){
for(int j = 0; j < len - i - 1; j++){
if(arr[j] > arr[j + 1]){
int tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
}
}
//2. 插入排序：
//时间复杂度：最好O(n), 最坏O(n^2)
//评价：稍快于冒泡
//1.先认为第一个最小
//2.第二个与第一个比较，如果第二个小，则交换。
//3.第N次循环的时候，前面N个元素都是排好序的。
static void standInsertSort(int arr[], int start, int end){
int len = end - start + 1;
for(int i = 1; i < len; i++){
int tmp = arr[i];
int j = -1;
for(j = i - 1 ; j >= 0; j--){
if(arr[j] > tmp){
arr[j+1] = arr[j];
}else{
break;
}
}
arr[j+1] = tmp;
}
}
//3. 选择排序
//时间复杂度：同插入排序，可能比冒泡快点，比插入慢点。
//评价：无
//1.找到最小的放在最前面
//2.找到最小的放在第二位
//3. ... ...
static void selectSort(int arr[], int start, int end){
int len = end - start + 1;
int min = Integer.MAX_VALUE;
for(int i = 0; i < len - 1; i++){//给arr按位赋值
int mark = -1;
for(int j = i; j < len; j++){//找出最小值
if(arr[j] < min){
min = arr[j];
mark = j;
}
}
arr[mark] = arr[i];
arr[i] = min;//找到最小值
min = Integer.MAX_VALUE;//重置min
}
}
//4. 快速排序
//时间复杂度：n(logn)
//评价：比插入排序快
static void quickSort(int arr[], int start, int end){
int sStore = start, eStore = end;
int len = end - start + 1;
switch(len){
case 0:
case 1:
return;
case 2:
arr[0] = arr[0]^arr[1];
arr[1] = arr[0]^arr[1];
arr[0] = arr[0]^arr[1];
return;
}
int mark = arr[start];//需要从右面找一个比mark小的值来填充arr[start]
//System.out.println("Sorts.quickSort() 时间复杂度为 " + len);
while(start < end){
while(arr[end] > mark && end > start){
end--;
}
if(end > start){//找到了，则填充arr[start]
arr[start] = arr[end];
start++;//start值确定所以，加一。
}else{//没有找到，这表示start右面的值全都比mark大了。。此时end == start，循环结束
}
//此时，arr[start]与arr[end]重复了。。需要从左面找一个比mark大的值来填充arr[end]。
//方法同上
while(arr[start] < mark&& end > start){
start++;
}
if(end > start){//找到了,填充arr[end]
arr[end] = arr[start];
end--;//end值确定，所以减一。
}else{//没找到，这表示start左面的值全部比mark小了。。
}
}
//我们知道，每次按照算法计算一次循环之后，数组中都会出现2个相同的值，所以会缺少一个值，这个值就是mark。
//因为我们从开头把mark提取之后，就没有把它赋回。
//所以mark应该放哪呢？
//因为循环结束只有一种可能，就是(start == end)这意味着什么？
//意味着：start的左面全部比mark小，end的右面全部比mark大。
//结果明确了吧。把start赋值成mark就恰好达到我们的要求了。
arr[start] = mark;
//至此，数组从0-->start的值，全部比start+1 --> end的值要小了。
//果断递归
quickSort(arr, sStore, start - 1);//之前写的不是start-1而是start，结果数据若超过65536会栈溢出。
quickSort(arr, start+1, eStore);
}
//5. 堆排序
//时间复杂度: n/2 + log(n) + log(n-1) + ...+ log1 ==> n(logn)
static class heapSort{
private static void swapArrayElement(int array[], int a, int b){
if(a == b){
return;
}
array[a] = array[a]^array[b];
array[b] = array[a]^array[b];
array[a] = array[a]^array[b];
}
private static void judgeHeap(int array[], int i, int len){//调整第i个元素为顶的3元大根堆
int lChild = 2*i + 1;
int rChild = 2*i + 2;
if(lChild > len - 1){
return;
}
if(rChild > len - 1){
if(array[i] < array[lChild]){
swapArrayElement(array, i, lChild);
}
return;
}
int max = i;
if(array[i] < array[lChild]){
max = lChild;
}
if(array[max] < array[rChild]){
max = rChild;
}
if(max != i){
swapArrayElement(array, max, i);
judgeHeap(array, max, len);
}
}
static void hSort(int array[], int from, int to) {
int len = to - from + 1;
if (len <= 1) {
return;
}
for (int i = len - 1; i >= 0; i--) {//创建初始堆，从最后一个元素开始作为3元堆顶，
//使其满足堆定义。这样总能把最大元素推到堆顶。
judgeHeap(array, i, len);
}
for(int i = 0; i < len; i++){
swapArrayElement(array, 0, len - i - 1);//把最大元素放到末尾。
judgeHeap(array, 0, len - i - 1);//改变的元素可能不符合堆定义。
}
}
}
//6.归并
//分治法
//>如果问题缩小到一定规模可以很容易求解
//>可以分解成相同的子问题
//>问题可由子问题的结果合并而得出。(是否使用分治法，完全取决于此点)
//>各个子问题之间是相互独立的，不包含公共子问题。(动态规划)
//晕了 搞了好久。。这样是不是占用空间太大了阿。。fak
//时间复杂度：n(logn)
static class MergerSort{
static void printArr(String tag, int arr[], int f, int to){}
static int[] merge(int arr1[],int arr2[]){
int l1 = arr1.length;
int l2 = arr2.length;
int re[] = new int[l1 + l2];
int o = 0;
int t = 0;
for(int i = 0; i < re.length; i++){
if(o > l1 - 1){
re[i] = arr2[t];
t++;
}else if(t > l2 - 1){
re[i] = arr1[o];
o++;
}else if(arr1[o] < arr2[t]){
re[i] = arr1[o];
o++;
}else{
re[i] = arr2[t];
t++;
}
}
return re;
}
static int [] mSort(int []arr, int from, int to){
int len = to - from + 1;
if(len == 1){
return new int[]{arr[from]};
}
int mid = (from + to) / 2;
int[] l = mSort(arr, from, mid);
int[] r = mSort(arr, mid+1, to);
return merge(l, r);
}
}
// 7.希尔
static void shellSort(int arr[], int from, int to) {
int len = to - from + 1;
if (len == 1) {
return;
}
int d = len % 2 == 0 ? len / 2 : len / 2 + 1;
while (d >= 1) {
//下面是一个典型插入排序
for (int i = d; i < len; i++) {
int tmp = arr[i];
int j = -1;
for (j = i - d; j >= 0; j -= d) {
if (arr[j] > tmp) {
arr[j + d] = arr[j];
} else {
break;// !!
}
}
arr[j + d] = tmp;// 因为最后一位
}
d = d % 2 == 0 || d == 1 ? d / 2 : d / 2 + 1;
}
}
//8.基数
//基数排序很厉害哇
//时间复杂度: 2 * n * (最大的数的位数)
static class RadixSort{
private static class list{
LinkedList<Integer> l = new LinkedList<Integer>();
LinkedList<Integer> getL(){
return l;
}
public list(){
}
void add(int value){
l.add(value);
}
void clear(){
l.clear();
}
int size(){
return l.size();
}
}
private static class lists{
private static list []l = new list[10];
static void reset(){//重置所有的桶
for(int i = 0; i < l.length; i++){
if(l[i] != null && l[i].size()!=0){
l[i].clear();
}
if(l[i] == null){
l[i] = new list();
}
}
}
static list get(int index){//得到一个桶
return l[index];
}
static void set(int index, int value){//往某个桶中添加数据
l[index].add(value);
}
}
static void rSort(int arr[], int from, int to){
int len = to - from + 1;
if(len <= 1){
return;
}
int times = 1;
int currentTime = 0;
int label = 1;
while(currentTime < times){
label = 10 * label;
lists.reset();
boolean timesMark = false;
for(int i = 0; i < len; i++){//进桶
int invalue = (arr[i]%label)/(label/10);//计算当前数放到哪个桶
lists.set(invalue, arr[i]);
if(!timesMark && arr[i]/label >= 1){//支持数值最大值为(9,9999,9999)否则。label超过Integer.MAX_VALUE会出错。
times++;
timesMark = true;
}
}
int i = 0;
for(int j = 0; j < 10; j++){
for(Integer value: lists.get(j).getL()){
arr[i] = value;
i++;
}
}
currentTime++;
}
}
}
public static void main(String[] args) {//测试
int arr[] = {8, 91, 411, 2222, 33333, 744444, 6555555, 56666666,1010101010,1010101011, 15554444, 212112211,};
//int arr[] = {81, 19, 44, 222, 323, 712, 56, 523, 15, 12,};
System.out.println("Sorts.main() before");
System.out.println(Arrays.toString(arr));
//BubbleSort(arr, 0, arr.length - 1);
//arr = insertSort(arr, 0, arr.length - 1);
//arr = selectSort(arr, 0, arr.length - 1);
//quickSort(arr, 0, arr.length - 1);
// heapSort.hSort(arr, 0, arr.length-1);
//arr = MergerSort.mSort(arr, 0, arr.length-1);
//standInsertSort(arr, 0, arr.length-1);
//selectSort(arr, 0, arr.length-1);
// shellSort(arr, 0, arr.length-1);
RadixSort.rSort(arr, 0, arr.length-1);
System.out.println("Sorts.main() after");
System.out.println(Arrays.toString(arr));
int x[] = new int[8000000];
for(int i = 0; i < x.length; i++){
x[i] = (int)(Math.random()* (Integer.MAX_VALUE/100));
}
long currentTime = System.currentTimeMillis();
System.out.println("Sorts.main() startTime = " + currentTime);
//selectSort(x, 0, x.length - 1);
//quickSort(x, 0, x.length - 1);
//heapSort.hSort(x, 0, x.length - 1);
// MergerSort.mSort(x, 0, x.length-1);
// shellSort(x, 0, x.length-1);
RadixSort.rSort(x, 0, x.length-1);//发现不如快速排序快。。估计是用了ArrayList的缘故。。
System.out.println("Sorts.main() consumeTime = " + (System.currentTimeMillis() - currentTime));
}
}note：我以为我忘记了，可是看到她的时候，竟然会全身发抖。。我真的是太弱了。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 八大排序算法：插入（2：插入、希尔）、选择（2：选择、堆）、交换（2：冒泡、快速）、归并、基数
- 十种排序算法总结（冒泡、插入、选择、希尔、归并、堆、快速，计数，桶，基数）
- 十种排序算法总结（冒泡、插入、选择、希尔、归并、堆、快速，计数，桶，基数）
- 十种排序算法总结（冒泡、插入、选择、希尔、归并、堆、快速，计数，桶，基数）
- 十种排序算法总结（冒泡、插入、选择、希尔、归并、堆、快速，计数，桶，基数）
- [置顶] 十种排序算法总结（冒泡、插入、选择、希尔、归并、堆、快速，计数，桶，基数）
- Java-十种内部排序实现（选择，冒泡，插入，希尔，堆，归并，快速，基数，计数，桶）及代码下载
- 十种排序算法总结（冒泡、插入、选择、希尔、归并、堆、快速，计数，桶，基数）
- 10种排序算法总结（冒泡、选择、插入、希尔、归并、快速、堆、拓扑、锦标赛、基数）
- 十种排序算法总结（冒泡、插入、选择、希尔、归并、堆、快速，计数，桶，基数）[转]
- Java语言实现九大排序算法（快速、归并、堆、选择、插入、计数、基数、希尔、冒泡）
- 10种排序算法总结（冒泡、选择、插入、希尔、归并、快速、堆、拓扑、锦标赛、基数）
- 数据结构排序（简单易懂口语化）--冒泡，快速，直接插入，希尔，直接选择，堆，归并，基数
- 数据结构 27 排序 排序-选择 插入 冒泡 希尔 快速归并 6种排序
- 常用排序算法总结（插入、冒泡、快速，堆、选择、希尔、归并）
- 基本的排序算法(选择、插入、冒泡、希尔、归并、堆、快速)
- 常用排序算法总结(插入、冒泡、选择、希尔、快速、归并、堆)
- 六种排序方法的学习（直接插入、希尔、冒泡、快速、选择、归并）
- C++排序算法总结(冒泡、插入、选择、希尔、归并、快速、堆)
- 八种排序算法（直接插入，希尔，直接选择，堆，冒泡，快排，归并，基数）