最近学习了下java,感觉java在基本语法上与C++非常相似。作为练习,我用java实现了冒泡排序、选择排序、插入排序、基尔排序、快速排序、堆排序、计数排序、合并排序。

以下为实现代码:

public class Sort{
public void print_arr(int[] arr){
int len = arr.length;
for (int i = 0; i < len; i++){
System.out.print("" + arr[i] + " ");
}
System.out.println("");
} public int[] dup_arr(int[] arr){
int len = arr.length;
int re[] = new int[len];
for (int i = 0; i < len; i++){
re[i] = arr[i];
}
return re;
} public int[] bubble(int[] arr){
int dup[] = this.dup_arr(arr);
int len = dup.length;
int tmp = 0;
for (int i = 0; i < len; i++){
for (int j = 0; j < len - 1 - i; j++){
if (dup[j] < dup[j+1]){
tmp = dup[j];
dup[j] = dup[j+1];
dup[j+1] = tmp;
}
}
}
return dup;
} public int[] selection(int[] arr){
int dup[] = this.dup_arr(arr);
int len = dup.length;
int tmp = 0;
int max = 0;
for (int i = 0; i < len; i++){
max = i;
for (int j = i + 1; j < len; j++){
if (dup[j] > dup[max]){
max = j;
}
}
tmp = dup[i];
dup[i] = dup[max];
dup[max] = tmp;
} return dup;
} public int[] insertion(int[] arr){
int dup[] = this.dup_arr(arr);
for (int i = 1; i < dup.length; i++){
int key = dup[i];
int j = i - 1;
while (j >= 0 && dup[j] < key){
dup[j + 1] = dup[j];
j--;
}
dup[j + 1] = key;
}
return dup;
} public int[] shell(int[] arr, int step){
int dup[] = this.dup_arr(arr);
while (step > 0){
//insertion sorting
for (int i = step; i < dup.length; i += step){
int j = i - step;
int key = dup[i];
while (j >= 0 && dup[j] < key){
dup[j + step] = dup[j];
j -= step;
}
dup[j + step] = key;
}
step = step / 2;
}
return dup;
} public void quick(int[] dup, int leftpoint, int rightpoint){
if (leftpoint >= rightpoint){
return;
}
int key = dup[rightpoint];
int left = leftpoint;
int right = rightpoint;
while (true){
while (left < right && dup[left] >= key){
left++;
}
while (left < right && dup[right] <= key){
right--;
}
int tmp = 0;
if (left >= right){
tmp = dup[right];
dup[right] = key;
dup[rightpoint] = tmp;
break;
}
tmp = dup[right];
dup[right] = dup[left];
dup[left] = tmp;
}
this.quick(dup, leftpoint, left - 1);
this.quick(dup, left + 1, rightpoint);
} //min heap
public int micro_adjust(int[] arr, int i, int last){
if (2 * i + 1 > last){
return i;
} int max = arr[i] < arr[2 * i + 1] ? i : (2 * i + 1);
if (2 * i + 2 > last){
return max;
} max = arr[max] < arr[2 * i + 2] ? max : (2 * i + 2);
if (max != i){
int tmp = arr[i];
arr[i] = arr[max];
arr[max] = tmp;
} return max;
}
//part of heap sorting. build a min heap
public void build_heap(int[] arr, int last){
int mid = (last + 1) / 2 - 1;
for (int i = mid; i >= 0; i--){
int tmp = micro_adjust(arr, i, last);
//System.out.print("i: " + i + " tmp: " + tmp + "arr: ");
//this.print_arr(arr);
int flag = i;
while (tmp <= mid && tmp != flag){
flag = tmp;
tmp = micro_adjust(arr, tmp, last);
}
}
return;
}
//part of heap sorting. adjust the left arr
public void adjust_heap(int[] arr, int last){
int tmp = arr[0];
arr[0] = arr[last];
arr[last] = tmp;
this.build_heap(arr, last - 1);
return;
}
//use min heap to sort arr from big to small
public int[] heap(int[] arr){
int dup[] = this.dup_arr(arr);
this.build_heap(dup, dup.length - 1);
for (int i = 0; i < dup.length; i++){
//System.out.print("i: " + i + " arr: ");
//this.print_arr(dup);
adjust_heap(dup, dup.length - 1 - i);
}
return dup;
} public int[] counting(int[] arr){
int min = arr[0];
int max = arr[0];
for (int i = 1; i < arr.length; i++){
min = min < arr[i] ? min : arr[i];
max = max > arr[i] ? max : arr[i];
} int buckets[] = new int[max - min + 1];
int index = 0;
for (int i = 0; i < arr.length; i++){
index = arr[i] - min;
buckets[index]++;
} int res[] = new int[arr.length];
for (int i = 0; i < res.length; i++){
res[i] = -1;
} for (int i = 0; i < arr.length; i++){
index = arr[i] - min;
int cnt = 0;
for (int j = 0; j < index; j++){
cnt += buckets[j];
}
while (res[res.length - 1 - cnt] != -1){
cnt++;
}
res[res.length - 1 - cnt] = arr[i];
}
return res;
} /*Failure: don't know how to build the buckets arr ......
public int[] radix(int[] arr){
int dup[] = this.dup_arr(arr); Queue[] buckets = new Queue[10];
for (int i = 0; i < 10; i++){
buckets[i] = new LinkedList();
} int max = dup[0];
for (int i = 1; i < dup.length; i++){
max = max > dup[i] ? max : dup[i];
} int n = 10;
while (max > 0){
for (int i = 0; i < dup.length; i++){
buckets[dup[i] % n].add(dup[i]);
}
int j = 0;
for (int i = 0; i < 10; i++){
while (!buckets[i].isEmpty()){
dup[j++] = buckets[i].getFirst();
buckets[i].removeFirst();
}
}
max /= 10;
n *= 10;
}
return dup;
}
*/ //part of merge sorting: merge two arr together
public int[] merge(int[] arr1, int[] arr2){
int res[] = new int[arr1.length + arr2.length];
int i = 0;
int j = 0;
int k = 0;
while (i < arr1.length && j < arr2.length){
if (arr1[i] > arr2[j]){
res[k++] = arr1[i++];
}else{
res[k++] = arr2[j++];
}
} while (i < arr1.length){
res[k++] = arr1[i++];
}
while (j < arr2.length){
res[k++] = arr2[j++];
}
return res;
}
//the main part of merge_sort
public int[] merge_sort(int[] arr, int start, int end){
//System.out.println("start: " + start + " end: " + end);
if (end - start < 1){
//System.out.println("end == start");
int tmp[] = {arr[start]};
return tmp;
} int flag = (end - start) / 2;
int res1[] = merge_sort(arr, start, start + flag);
//System.out.println("res1:");
//this.print_arr(res1);
int res2[] = merge_sort(arr, start + flag + 1, end);
//System.out.println("res2:");
//this.print_arr(res2);
int res[] = merge(res1, res2);
//this.print_arr(res);
return res;
} public static void main(String[] args){
int arr[] = {6, 6, 7, 5, 3, 2, 4, 1, 8, 9, 0};
Sort s = new Sort();
System.out.print("The original array: ");
s.print_arr(arr); System.out.print("after bubble sorting: ");
s.print_arr(s.bubble(arr)); System.out.print("after selection sorting: ");
s.print_arr(s.selection(arr)); System.out.print("after insertion sorting: ");
s.print_arr(s.insertion(arr)); System.out.print("after shell sorting: ");
s.print_arr(s.shell(arr, arr.length/2)); System.out.print("after quick sorting: ");
int dup[] = s.dup_arr(arr);
s.quick(dup, 0, dup.length - 1);
s.print_arr(dup); System.out.print("after heap sorting: ");
s.print_arr(s.heap(arr)); System.out.print("after counting sorting: ");
s.print_arr(s.counting(arr)); //failure: because don't know how to define buckets
//System.out.print("after radix sorting: ");
//s.print_arr(s.radix(arr)); //failure: because don't know how to define buckets
//System.out.print("after buckets sorting: ");
//s.print_arr(s.buckets(arr)); System.out.print("after merge sorting: ");
dup = s.dup_arr(arr);
s.print_arr(s.merge_sort(dup, 0, dup.length - 1));
}
}

常见排序算法及其java实现的更多相关文章

  1. 常见排序算法(附java代码)

    常见排序算法与java实现 一.选择排序(SelectSort) 基本原理:对于给定的一组记录,经过第一轮比较后得到最小的记录,然后将该记录与第一个记录的位置进行交换:接着对不包括第一个记录以外的其他 ...

  2. 常见排序算法总结 -- java实现

    常见排序算法总结 -- java实现 排序算法可以分为两大类: 非线性时间比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此称为非线性时间比较类排序. 线性时间 ...

  3. 常见排序算法(java实现)

    常见排序算法介绍 冒泡排序 代码: public class BubbleSort { public static void sort(int[] array) { int tValue; for ( ...

  4. 几种常见排序算法之Java实现(插入排序、希尔排序、冒泡排序、快速排序、选择排序、归并排序)

    排序(Sorting) 是计算机程序设计中的一种重要操作,它的功能是将一个数据元素(或记录)的任意序列,重新排列成一个关键字有序的序列. 稳定度(稳定性)一个排序算法是稳定的,就是当有两个相等记录的关 ...

  5. 几种常见排序算法的java实现

    一.几种常见的排序算法性能比較 排序算法 最好时间 平均时间 最坏时间 辅助内存 稳定性 备注 简单选择排序 O(n^2) O(n^2) O(n^2) O(1) 不稳定 n小时较好 直接插入排序 O( ...

  6. 常见排序算法及Java实现

    先上个总图↓: ①.直接插入排序 插入排序(Insertion Sort)的算法描述是一种简单直观的排序算法.它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并 ...

  7. 六种常见排序算法的java实现

    package edu.cn.ysw; //八种排序算法的实现与效率分析 /* * 内排序的种类: * 1.插入排序:直接插入排序.希尔排序. * 2.选择排序:简单选择排序.堆排序. 3.交换排序: ...

  8. 常见排序算法题(java版)

    常见排序算法题(java版) //插入排序:   package org.rut.util.algorithm.support;   import org.rut.util.algorithm.Sor ...

  9. Java基础语法(8)-数组中的常见排序算法

    title: Java基础语法(8)-数组中的常见排序算法 blog: CSDN data: Java学习路线及视频 1.基本概念 排序: 是计算机程序设计中的一项重要操作,其功能是指一个数据元素集合 ...

随机推荐

  1. Redpine的Lite-Fi解决方案获Wi-Fi CERTIFIED认证

    应用微电路公司(AMCC)和Redpine Signals日前共同宣布,已合作开发出新一代基于Power Architecture的嵌入式Wi-Fi连接性解决方案,目前双方已经在AMCC的PowerP ...

  2. 查询json数据结构的8种方式

    查询json数据结构的8种方式 你有没有对“在复杂的JSON数据结构中查找匹配内容”而烦恼.这里有8种不同的方式可以做到: JsonSQL JsonSQL实现了使用SQL select语句在json数 ...

  3. Codeforces 380A - Sereja and Prefixes

    原题地址:http://codeforces.com/problemset/problem/380/A 让期末考试整的好久没有写题, 放假之后由于生病也没怎么做,新年的第一场CF也不是那么在状态,只过 ...

  4. 扫描.net dll引用dll

    最近升级系统里的NHibernate,从3.3到4,项目工程太多, 一个模块分bll,dal,model,web,test,10几个模块,就要60多dll,升级一次太头疼. 编译过后,有时候会有的dl ...

  5. bzoj1532

    就题目而言,这道题是裸的二分+最大流 但是这样是TLE的,我们考虑优化 1. 我们可以先贪心,这样二分的上界就可以缩小了 2. 最大流我们可以不急着跑增广路,我们可以先贪心一个流然后再跑增广路 但是我 ...

  6. 深入理解Arrays.sort()

    两种方法: 1.类本来就实现java.lang.Comparable接口,使类本身就有比较能力.接口实现compareTo方法,次方法接收另一个Object为参数,如果当前对象小于参数则返回负值,如果 ...

  7. NFA和DFA区别

    一个数据块的访问时间等于寻道时间.旋转延迟时间和数据传输时间三者之和: NFA和DFA区别: 一个状态如A,遇0可以转换到下一个状态B或C,因为选择多所以不确定,因此为不确定的有限自动机: 一个状态还 ...

  8. Spring基础知识及bean的配置

    IOC与DI: IOC(inversion of control):其思想是反转资源获取的方向.传统的资源查找方式要求组件向容器发起请求查找资源.作为回应,容器适时的返回资源.而应用了IOC之后,则是 ...

  9. POJ 3208-Apocalypse Someday(数位dp)

    题意:给定n,输出第n大包含666的数字. 分析:dp[i][j][k][l]表示 长度为i,当前位是否是6,前一位是否6,是否已经包含666,表示的数量,再用二分找出第n大的这样的数字. #incl ...

  10. bindService和startService的区别

    区别: startService,关闭服务退出activity,service仍然处于后台运行 bindService,关闭服务退出activity直接stopService,停止服务 bindSer ...