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 ...
随机推荐
- 在Hexo中渲染MathJax数学公式
最近学机器学习涉及很多的数学公式,公式如果用截图显示,会比较low而且不方便.因此需要对Hexo做些配置,支持公式渲染.同时文末整理了各种公式的书写心得,比如矩阵.大小括号.手动编号.上下角标和多行对 ...
- ROS知识（14）----局部避障的动态窗口算法（DWA）及其调试的方法
Dynamic Window Approach(DWA)是重要的局部轨迹规划算法,ROS中使用了DWA算法获得了很好的局部路径规划的效果.具体的教程可参考官方的导航调试资料Navigation Tun ...
- 使用Django来处理对于静态文件的请求
引言 本方法适用于linux+python2.7+django1.2,使用django自带的web服务. 同样也适用于sina app engine. 1.准备工作 准备css文件,准备js文件,准备 ...
- [重要更新][Quartus II][14.1正式版]
[Quartus II][14.1正式版] ----14.1版本最大的变化就是增加了2大系列的器件库: MAX 10和Arria 10.这2大系列据Altera中国区代理 骏龙科技的人说,就是为了和X ...
- 淘宝API得到单个商品的信息，用了淘宝的SDK...
淘宝api获取到的数据.返回结果可以选择json格式和xml格式的啊.每个api下面都有sdk调用示例哦. 详细:http://wenwen.soso.com/z/q335640192.htm 淘宝开 ...
- [Asp.net MVC]页面伪静态实现
摘要 从页面Url及页面名称上看,你会发现静态页面和伪静态是一样的.伪静态的页面后缀可能是html,htm,cshtml等,只是改变了url的表现形式,实际上还是动态的页面.在SEO方面,伪静态和静态 ...
- 重写Html.DropDownList和Html.DropDownListFor的name属性
□ 重写前 通常这样写: @Html.DropDownListFor(m => m.DelFlag,(List<SelectListItem>)ViewBag.d,"==请 ...
- Myeclipse反编译插件(jad)的安装和使用
在开发过程中我们肯定会遇到这样的问题,当我们调试程序的时候,走到一个地方发现引用了一个第三方的东西,点进去一看,会出现一下的画面,没有源代码!!!! 这让人很头疼,今天给大家介绍一个Myeclipse ...
- Java发邮件带附件测试通过
package cn.bric.crm.util; import java.util.Date; import java.util.Enumeration; import java.util.Prop ...
- 仿LOL项目开发第七天
仿LOL项目开发第七天 by 草帽 不知不觉已经写到了第七篇这种类型的博客,但是回过头看看之前写的,发现都只能我自己能看懂. 我相信在看的童鞋云里雾里的,因为我基本上没怎么详细讲一个脚本怎么用?但是你 ...