java实现内部排序算法
- 冒泡排序
public class BubbleSort{
public static int[] asc(int[] a){
int item;
for (int i = 0; i < a.length-1; i++) {
item = a[i];
for (int j = i+1; j < a.length; j++) {
if (a[j]<a[i]) {
a[i] = a[j];
a[j] = item;
item = a[i];
}
}
}
return a;
}
public static int[] desc(int[] a){
int item;
for (int i = 0; i < a.length-1; i++) {
item = a[i];
for (int j = i+1; j < a.length; j++) {
if (a[j]>a[i]) {
a[i] = a[j];
a[j] = item;
item = a[i];
}
}
}
return a;
}
public static void main(String[] args) {
int a[] = {23,14,25,32,8,27,15,13,58,8,2,36};
a = asc(a);
pump(a);
}
private static void pump(int[] a) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+"\t");
}
System.out.println("\n");
}
}
- 堆排序
public class HeapSort{
public static int[] asc(int[] a){
a = buildHeap(a);
int item;
for (int i = a.length-1; i >=1; i--) {
item = a[0];
a[0] = a[i];
a[i] = item;
heapAdjust(a,0,i-1);
}
return a;
}
private static int[] buildHeap(int[] a) {
return buildHeap(a,true);
}
private static int[] buildHeap(int[] a,boolean asc) {
for (int i = a.length/2; i >= 0; i--) {
a = heapAdjust(a,i,a.length-1,asc);
}
return a;
}
public static int[] heapAdjust(int[] a,int index,int size){
return heapAdjust(a, index, size, true);
}
public static int[] heapAdjust(int[] a,int index,int size,boolean asc){
int left = index*2 + 1;
int right = left + 1;
int max = index;
if (left<=size) {
if (asc&&a[left]>a[max]) {
max = left;
}
if (!asc&&a[left]<a[max]) {
max = left;
}
}
if (right<=size) {
if (asc&&a[right]>a[max]) {
max = right;
}
if (!asc&&a[right]<a[max]) {
max = right;
}
}
if (max != index) {
int temp = a[max];
a[max] = a[index];
a[index] = temp;
heapAdjust(a, max, size, asc);
}
return a;
}
public static int[] desc(int[] a){
a = buildHeap(a,false);
int item;
for (int i = a.length-1; i >=1; i--) {
item = a[0];
a[0] = a[i];
a[i] = item;
heapAdjust(a,0,i-1,false);
pump(a);
}
return a;
}
public static void main(String[] args) {
int a[] = {23,14,25,32,8,27,15,13,58,8,2,36};
a = desc(a);
pump(a);
}
private static void pump(int[] a) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+"\t");
}
System.out.println("\n");
}
}
- 插入排序
public class InsertSort{
public static int[] asc(int[] a){
int item;
for (int i = 0; i < a.length-1; i++) {
item = a[i+1];
for (int k = i; k >= 0; k--) {
if (a[k]>item) {
a[k+1] = a[k];
a[k] = item;
}else {
break ;
}
}
}
return a;
}
public static int[] desc(int[] a){
int item;
for (int i = 0; i < a.length-1; i++) {
item = a[i+1];
for (int k = i; k >= 0; k--) {
if (a[k]<item) {
a[k+1] = a[k];
a[k] = item;
}else {
break ;
}
}
}
return a;
}
public static void main(String[] args) {
int a[] = {23,14,25,32,18,27,15,13,58,8,2,36};
a = desc(a);
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
}
- 归并排序
public class MergeSort{
public static int[] asc(int[] a){
return asc(a,0,a.length-1);
}
public static int[] asc(int[] a,int start,int end){
if (start<end) {
if (start+1==end) {
if(a[start]>a[end]){
int temp = a[start];
a[start] = a[end];
a[end] = temp;
}
return a;
}
int m = (start+end)/2;
a = asc(a,start,m);
a = asc(a,m+1,end);
a = merge(a,start,m,end);
}
return a;
}
private static int[] merge(int[] a, int start, int m, int end) {
for (int j = m+1; j <= end; j++) {
int index = j,i=j-1,item = a[j];
while (i >= start&&item<a[i]) {
index = i--;
}
if (index != j) {
for (int k = j; k >index; k--) {
a[k] = a[k-1];
}
a[index] = item;
}
}
return a;
}
private static int[] merge(int[] a, int start, int m, int end,boolean asc) {
for (int j = m+1; j <= end; j++) {
int index = j,i=j-1,item = a[j];
if (asc) {
while (i >= start&&item<a[i]) {
index = i--;
}
}else {
while (i >= start&&item>a[i]) {
index = i--;
}
}
if (index != j) {
for (int k = j; k >index; k--) {
a[k] = a[k-1];
}
a[index] = item;
}
}
return a;
}
public static int[] desc(int[] a){
return desc(a,0,a.length-1);
}
private static int[] desc(int[] a,int start,int end) {
if (start<end) {
if (start+1==end) {
if(a[start]<a[end]){
int temp = a[start];
a[start] = a[end];
a[end] = temp;
}
return a;
}
int m = (start+end)/2;
a = desc(a,start,m);
a = desc(a,m+1,end);
a = merge(a,start,m,end,false);
}
return a;
}
public static void main(String[] args) {
int a[] = {23,14,25,32,8,27,15,13,58,8,2,36};
a = desc(a);
pump(a);
}
private static void pump(int[] a) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+"\t");
}
System.out.println("\n");
}
}
- 快速排序
public class QuickSort {
public static int[] asc(int[] a, int low, int high) {
if (low >= high || (a[low] <= a[high] && low + 1 == high)) {
return a;
} else if (a[low] > a[high] && low + 1 == high) {
int temp = a[high];
a[high] = a[low];
a[low] = temp;
return a;
}
int tag = a[low], start = low, end = high;
boolean left_right = false;
while (low < high) {
if (!left_right) {
if (a[high] < tag) {
a[low] = a[high];
a[high] = tag;
low++;
left_right = true;
} else {
high--;
}
} else {
if (a[low] > tag) {
a[high] = a[low];
a[low] = tag;
left_right = false;
high--;
} else {
low++;
}
}
}
if (start < high) {
a = asc(a, start, high == low ? high - 1 : high);
}
if (low < end) {
a = asc(a, low == high ? low + 1 : low, end);
}
return a;
}
public static int[] desc(int[] a, int low, int high) {
if (low >= high || (a[low] >= a[high] && low + 1 == high)) {
return a;
} else if (a[low] < a[high] && low + 1 == high) {
int temp = a[high];
a[high] = a[low];
a[low] = temp;
return a;
}
int tag = a[low], start = low, end = high;
boolean left_right = false;
while (low < high) {
if (!left_right) {
if (a[high] > tag) {
a[low] = a[high];
a[high] = tag;
low++;
left_right = true;
} else {
high--;
}
} else {
if (a[low] < tag) {
a[high] = a[low];
a[low] = tag;
left_right = false;
high--;
} else {
low++;
}
}
}
if (start < high) {
a = desc(a, start, high == low ? high - 1 : high);
}
if (low < end) {
a = desc(a, low == high ? low + 1 : low, end);
}
return a;
}
public static void main(String[] args) {
int a[] = { 23, 14, 25, 32, 8, 27, 15, 13, 58, 8, 2, 36 };
a = desc(a, 0, a.length - 1);
pump(a);
}
private static void pump(int[] a) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + "\t");
}
System.out.println("\n");
}
}
- 基数排序
public class RadixSort {
private static int[] radix(int[] a, int radix, boolean asc) {
int[][] index = new int[10][];
int pow = Double.valueOf(Math.pow(10, radix)).intValue(), bucket = 0;
for (int i = 0; i < a.length; i++) {
bucket = a[i] % pow / (pow / 10);
if (index[bucket] == null) {
index[bucket] = new int[] { a[i] };
} else {
index[bucket] = add(index[bucket], a[i]);
}
}
int k = 0;
int[] b = new int[a.length];
if (asc) {
for (int i = 0; i < 10; i++) {
if (index[i] != null && index[i].length > 0) {
System.arraycopy(index[i], 0, b, k, index[i].length);
k += index[i].length;
}
}
} else {
for (int i = 9; i >= 0; i--) {
if (index[i] != null && index[i].length > 0) {
System.arraycopy(index[i], 0, b, k, index[i].length);
k += index[i].length;
}
}
}
return b;
}
private static int[] add(int[] a, int v) {
if (a == null || a.length == 0) {
return new int[] { v };
} else {
int[] b = new int[a.length + 1];
System.arraycopy(a, 0, b, 0, a.length);
b[a.length] = v;
return b;
}
}
public static int[] asc(int[] a) {
int bucket = 1, max = 0;
for (int i = 1; i < a.length; i++) {
if (a[i] > a[max]) {
max = i;
}
}
bucket = String.valueOf(a[max]).length();
for (int i = 1; i <= bucket; i++) {
a = radix(a, i, true);
}
return a;
}
public static int[] desc(int[] a) {
int bucket = 1, max = 0;
for (int i = 1; i < a.length; i++) {
if (a[i] > a[max]) {
max = i;
}
}
bucket = String.valueOf(a[max]).length();
for (int i = 1; i <= bucket; i++) {
a = radix(a, i, false);
}
return a;
}
public static void main(String[] args) {
int a[] = { 23, 14, 25, 32, 8, 27, 15, 13, 58, 8, 2, 36 };
a = desc(a);
pump(a);
}
private static void pump(int[] a) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + "\t");
}
System.out.println("\n");
}
}
- 选择排序
public class SelectSort{
public static int[] asc(int[] a){
int index;
for (int i = 0; i < a.length-1; i++) {
index = i;
for (int j = i+1; j < a.length; j++) {
if (a[j]<a[index]) {
index = j;
}
}
if (a[i]>a[index]) {
int item = a[i];
a[i] = a[index];
a[index] = item;
}
}
return a;
}
public static int[] desc(int[] a){
int index;
for (int i = 0; i < a.length-1; i++) {
index = i;
for (int j = i+1; j < a.length; j++) {
if (a[j]>a[index]) {
index = j;
}
}
if (a[i]<a[index]) {
int item = a[i];
a[i] = a[index];
a[index] = item;
}
}
return a;
}
public static void main(String[] args) {
int a[] = {23,14,25,32,8,27,15,13,58,8,2,36};
a = desc(a);
pump(a);
}
private static void pump(int[] a) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+"\t");
}
System.out.println("\n");
}
}
- 希尔排序
public class ShellSort {
public static int[] asc(int[] a) {
int d = (a.length + 1) / 2;
while (d >= 1) {
shell(a, d, true);
d = d / 2;
}
return a;
}
private static void shell(int[] a, int d, boolean asc) {
int item;
if (asc) {
for (int i = 0; i < d; i++) {
for (int j = i; j + d < a.length; j += d) {
item = a[j + d];
for (int k = j; k >= 0; k -= d) {
if (a[k] > item) {
a[k + d] = a[k];
a[k] = item;
} else {
break;
}
}
}
}
} else {
for (int i = 0; i < d; i++) {
for (int j = i; j + d < a.length; j += d) {
item = a[j + d];
for (int k = j; k >= 0; k -= d) {
if (a[k] < item) {
a[k + d] = a[k];
a[k] = item;
} else {
break;
}
}
}
}
}
}
public static int[] desc(int[] a) {
int d = (a.length + 1) / 2;
while (d >= 1) {
shell(a, d, false);
d = d / 2;
}
return a;
}
public static void main(String[] args) {
int a[] = { 23, 14, 25, 32, 18, 27, 15, 13, 58, 8, 2, 36 };
a = desc(a);
pump(a);
}
private static void pump(int[] a) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + "\t");
}
System.out.println("\n");
}
}
java实现内部排序算法的更多相关文章
- Java实现各种内部排序算法
数据结构中常见的内部排序算法: 插入排序:直接插入排序.折半插入排序.希尔排序 交换排序:冒泡排序.快速排序 选择排序:简单选择排序.堆排序 归并排序.基数排序.计数排序 直接插入排序: 思想:每次将 ...
- 用 Java 实现常见的 8 种内部排序算法
一.插入类排序 插入类排序就是在一个有序的序列中,插入一个新的关键字.从而达到新的有序序列.插入排序一般有直接插入排序.折半插入排序和希尔排序. 1. 插入排序 1.1 直接插入排序 /** * 直接 ...
- Java中的排序算法（2）
Java中的排序算法(2) * 快速排序 * 快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub-lists). * 步骤为: * 1. 从数 ...
- java实现各种排序算法
java实现各种排序算法 import java.util.Arrays; public class SomeSort { public static void main(String[] args) ...
- 常见内部排序算法对比分析及C++ 实现代码
内部排序是指在排序期间数据元素全部存放在内存的排序.外部排序是指在排序期间全部元素的个数过多,不能同时存放在内存,必须根据排序过程的要求,不断在内存和外存之间移动的排序.本次主要介绍常见的内部排序算法 ...
- 排序算法练习--JAVA(：内部排序：插入、选择、冒泡、快速排序）
排序算法是数据结构中的经典算法知识点,也是笔试面试中经常考察的问题,平常学的不扎实笔试时候容易出洋相,回来恶补,尤其是碰到递归很可能被问到怎么用非递归实现... 内部排序: 插入排序:直接插入排序 选 ...
- Java实现常见排序算法
常见的排序算法有冒泡排序.选择排序.插入排序.堆排序.归并排序.快速排序.希尔排序.基数排序.计数排序,下面通过Java实现这些排序 1.冒泡排序 package com.buaa; import j ...
- 七内部排序算法汇总（插入排序、Shell排序、冒泡排序、请选择类别、、高速分拣合并排序、堆排序）
写在前面: 排序是计算机程序设计中的一种重要操作,它的功能是将一个数据元素的随意序列,又一次排列成一个按keyword有序的序列.因此排序掌握各种排序算法很重要. 对以下介绍的各个排序,我们假定全部排 ...
- Java数组的排序算法
在Java中,实现数组的排序算法有很多,如冒泡排序法.选择排序法.直接插入法和快速排序法等.下面介绍几种排序算法的具体 实现. 本文引用文献:Java必须知道的300个问题. 1.冒泡排序法 1.1 ...
随机推荐
- [LeetCode] Pacific Atlantic Water Flow 题解
题意 题目 思路 一开始想用双向广搜来做,找他们相碰的点,但是发现对其的理解还是不够完全,导致没写成功.不过,后来想清楚了,之前的错误可能在于从边界点进行BFS,其访问顺序应该是找到下一个比当前那个要 ...
- UVALive 4426 Blast the Enemy! 计算几何求重心
D - Blast the Enemy! Time Limit:3000MS Memory Limit:0KB 64bit IO Format:%lld & %llu Subm ...
- request.setAttribute()、session.setAttribute()和request.getParameter()的联系与区别(记录)
1.session.setAttribute()和session.getAttribute()配对使用,作用域是整个会话期间,在所有的页面都使用这些数据的时候使用. 2.request.setAttr ...
- Tasker to answer incoming call by pressing power button
nowadays, the smartphone is getting bigger in size, eg. samsung galaxy note and note 2, sorta big in ...
- grep查看源代码用法
http://blog.csdn.net/guyongqiangx/article/details/70161189
- MVC扩展控制器, 把部分视图转换成字符串(带验证信息), 并以json传递给前端视图
当我们使用jQuery异步提交表单数据的时候,需要把部分视图转换成字符串(带验证信息),以json的形式传递给前端视图. 使用jQuery异步加载部分视图,返回内容追加到页面某个div: jQ ...
- 将一张表中的字段更新到另一张表的sql
UPDATE tb_user a INNER JOIN tb_doctor s ON s.id=a.id SET a.AVATAR=s.AVATAR UPDATE tb_user a INNER JO ...
- ubuntu 添加CDROM安装源
国内私募机构九鼎控股打造APP,来就送 20元现金领取地址:http://jdb.jiudingcapital.com/phone.html内部邀请码:C8E245J (不写邀请码,没有现金送)国内私 ...
- dwz navtab 限制打开数量实例
本文章给大家介绍一个dwz navtab 限制打开数量实例,希望此教程对各位同学会有所帮助 openTab: function(tabid, url, options){ //if found tab ...
- 使用 kubeadm 搭建 kubernetes1.10 集群
PS:所有节点安装之前记得先把镜像准备好,否者将无法启动,也不报错. $ cat /etc/hosts192.168.11.1 master192.168.11.2 node 禁用防火墙: $ sys ...