本例子实现了一些常见的排序算法,注释中也有一些关于这些算法的思想的描述,这里不做多说,直接上代码。

import java.awt.List;
import java.util.ArrayList;
import java.util.Hashtable; /**
* @ClassName: Sort
* @Description: //默认按照升序排序
*
*/
public class Sort {
/**
*
* @Description: 直接插入排序
* @author 陈杰
* @date 2016年10月7日 下午9:08:26
* @param arr
*/
public void directlyInsertSort(int[] arr){
if(arr==null||arr.length==0)
return;
//int i,j;
//初始默认arr[0]为已排好的序列
for(int i=1;i<arr.length;i++){
int temp=arr[i];
for(int j=i-1;j>=0;j--){
if(arr[j]>temp){ arr[j+1]=arr[j];//元素向后移动一位
arr[j]=temp;
}
} }
//打印排序后结果
for(int value:arr){
System.out.print(value+" ");
}
}
/**
*
* @Description: 希尔排序 (这里用一句话描述这个类的作用)
* @author 陈杰
* @date 2016年10月8日 下午7:24:16
* @param arr
* @param n
*/
public void shellSort(int arr[],int dk){
int temp=0;
for(int d=dk;d>0;d=d/2){
for(int i=d;i<arr.length;i++){
temp=arr[i];
//int index=-1;//待插入的位置
for(int j=i-d;j>=0;j=j-d){
if(arr[j]>temp){
//index=j;
arr[j+d]=arr[j];//元素向后移动一位
arr[j]=temp;
}
} }
}
//打印排序后结果
for (int value : arr) {
System.out.print(value + " ");
}
} /**
*
* @Description: 折半插入排序
* @author 陈杰
* @date 2016年10月8日 上午10:27:07
* @param arr
*/
public void halfInsertSort(int[] arr){
if(arr==null||arr.length==0)
return;
int i,j,low,high,mid;
for(i=1;i<arr.length;i++){
mid=0;
low=0;
high=i-1;
int temp=arr[i];
//折半获得插入位置
while(low<=high){
mid=(low+high)/2;
if(temp>arr[mid])
low=mid+1;
else
high=mid-1;
}
//移动位置
for(j=i-1;j>=high+1;--j){
arr[j+1]=arr[j];
}
arr[high+1]=temp; }
//打印排序后结果
for(int value:arr){
System.out.print(value+" ");
}
}
/**
*
* @Description: 冒泡排序(这里用一句话描述这个类的作用)
* @author 陈杰
* @date 2016年10月8日 上午11:14:05
* @param arr
*/
public void buddleSort(int[] arr){
if(arr==null||arr.length==0)
return;
int length=arr.length;
for(int i=0;i<length-1;i++){
for(int j=length-1;j>i;j--){
int temp=arr[j];
if(arr[j-1]>arr[j]){
arr[j]=arr[j-1];
arr[j-1]=temp;
}
}
}
//打印排序后结果
for(int value:arr){
System.out.print(value+" ");
}
}
/**
*
* @Description: 快速排序
* @author 陈杰
* @date 2016年10月8日 下午6:25:16
* @param arr
*/
public void quickSort(int[] arr,int low,int high){
if (arr == null || low < 0 || high < 0 || low >= arr.length) return;
if(low<high){
int pivotIndex=partion(arr, low, high);
quickSort(arr, low, pivotIndex-1);
quickSort(arr, pivotIndex+1, high);
} }
/**
*
* @Description: 快速排序的核心划分算法
* @author 陈杰
* @date 2016年10月8日 下午6:52:58
* @param arr
* @param low
* @param high
*/
private int partion(int[] arr,int low,int high){
int pivot=arr[low];
while(low<high){
while((low<high)&&arr[high]>=pivot)
high--;
arr[low]=arr[high];//将比基准小的移动到左侧
while((low<high)&&arr[low]<=pivot)
low++;
arr[high]=arr[low];//将比基准大的移动到右端
}
arr[low]=pivot;
return low; }
/**
*
* @Description: 简单选择排序 (这里用一句话描述这个类的作用)
* @author 陈杰
* @date 2016年10月8日 下午8:16:21
* @param arr
*/
public void selectSort(int arr[]){
for(int i=0;i<arr.length-1;i++){
int min=i;//记录本次待排序最小元素的位置
for(int j=i+1;j<arr.length;j++){
if(arr[min]>arr[j])
min=j;
}
//将未排序列表中的最小元素和待排序元素的位置互换
if(min!=i){
int temp=arr[i];
arr[i]=arr[min];
arr[min]=temp;
} }
//打印排序后结果
for (int value : arr) {
System.out.print(value + " ");
}
}
/**
*
* @Description: 堆排序算法 (这里用一句话描述这个类的作用)
* @author 陈杰
* @date 2016年10月9日 下午5:40:56
* @param arr
*/
public void heapSort(int arr[]){
if(arr==null||arr.length<=0)
return;
bulidHeap(arr);
for(int i=arr.length-1;i>=0;i--){
//交换堆顶元素和堆低元素的值,以打破堆让其重新调整,从而每次输出最大值(堆顶的值),直至堆为空
int temp=arr[0];//堆顶元素
arr[0]=arr[i];
arr[i]=temp;
adjustHeap(arr, 0, i);
} //打印排序后结果
for (int value : arr) {
System.out.print(value + " ");
}
}
/**
*
* @Description:构建初始堆(以大根堆为例)
* @author 陈杰
* @date 2016年10月9日 下午5:43:02
* @param arr
*/
private void bulidHeap(int arr[]){
int length=arr.length;
for(int i=length/2-1;i>=0;i--){
adjustHeap(arr,i,length-1);
}
}
/**
*
* @Description: 调整堆的方法,自下向上调整堆,含有递归部分
* @author 陈杰
* @date 2016年10月9日 下午5:48:00
* @param arr
* @param nodeIndex 分支节点的索引下标
* @param max
*/
private void adjustHeap(int arr[],int nodeIndex,int max){
int left=2*nodeIndex+1;//左孩子
int right=2*nodeIndex+2;//右孩子
int maxValueIndex=nodeIndex;//用来记录当前三个节点间最大值的下标值
if(left<max&&arr[left]>arr[nodeIndex])
maxValueIndex=left;
if(right<max&&arr[right]>arr[maxValueIndex])
maxValueIndex=right;
if(maxValueIndex!=nodeIndex){
//交换元素,构造堆
int temp=arr[nodeIndex];
arr[nodeIndex]=arr[maxValueIndex];
arr[maxValueIndex]=temp;
//对交换后的元素向下继续调整堆
adjustHeap(arr,maxValueIndex,max);
} }
/**
*
* @Description: 二路归并排序(基于分治的思想)
* @author 陈杰
* @date 2016年10月9日 下午6:50:15
* @param arr
* @param low
* @param high
*/
private void mergeSort(int[] arr,int low,int high){
if(low<high){
int mid=(low+high)/2;
mergeSort(arr,low,mid);
mergeSort(arr, mid+1,high);
merge(arr, low, mid, high);
}
}
/**
*
* @Description: 二路归并排序中将前后两个有序表合并成一个有序表的过程
* @author 陈杰
* @date 2016年10月9日 下午7:13:47
* @param arr
* @param low
* @param mid
* @param high
*/
private void merge(int arr[],int low,int mid, int high){
int[] temp=new int[high-low+1];//临时数组
int index=0;
int left=low;//左表的下标开始值
int right=mid+1;//右表的下标开始值
//比较两个表中较小的值将其放在临时数组中
while(left<=mid&&right<=high){
if(arr[left]>arr[right]){
temp[index++]=arr[right++];
}else{
temp[index++]=arr[left++];
}
}
//若左表中有剩余的元素,将其复制到临时表中
while(left<=mid)
temp[index++]=arr[left++];
//若右表中有剩余的元素,将其复制到临时表中
while(right<=high)
temp[index++]=arr[right++];
//将排好序的临时数组回归到原数组中,获得排序结果
for(int k=0;k<temp.length;k++)
arr[low+k]=temp[k]; }
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[]={1,4,2,6,3,9,6,5,3,8,6,3};
Sort sort=new Sort();
System.out.println("直接插入排序的结果:");
sort.directlyInsertSort(arr);
System.out.println();
System.out.println("折半插入排序的结果");
int arr2[]={1,4,2,6,3,9,6,5,3,8,6,3};
sort.halfInsertSort(arr2);
System.out.println();
System.out.println("冒泡排序的结果");
int arr3[]={1,4,2,6,3,9,6,5,3,8,6,3};
sort.buddleSort(arr3);
System.out.println();
System.out.println("快速排序的结果");
int arr4[]={1,4,2,6,3,9,6,5,3,8,6,3};
sort.quickSort(arr4, 0, arr4.length-1);
//打印排序后结果
for (int value : arr4) {
System.out.print(value + " ");
}
System.out.println();
System.out.println("希尔排序的结果");
int arr5[]={1,4,2,6,3,9,6,5,3,8,6,3};
sort.shellSort(arr5, 6);
System.out.println();
System.out.println("简单选择排序的结果");
int arr6[]={1,4,2,6,3,9,6,5,3,8,6,3};
sort.selectSort(arr6);
System.out.println();
System.out.println("堆排序的结果");
int arr7[]={1,4,2,6,3,9,6,5,3,8,6,3};
sort.heapSort(arr7);
System.out.println();
System.out.println("二路归并排序的结果");
int arr8[]={1,4,2,6,3,9,6,5,3,8,6,3};
sort.mergeSort(arr8, 0, arr8.length-1);
//打印排序后结果
for (int value : arr8) {
System.out.print(value + " ");
}
ArrayList<String> ss=new ArrayList<String>();
ss.equals(arr8);
ss.hashCode();
} }

基本排序算法的java实现的更多相关文章

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

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

  2. 几大排序算法的Java实现

    很多的面试题都问到了排序算法,中间的算法和思想比较重要,这边我选择了5种常用排序算法并用Java进行了实现.自己写一个模板已防以后面试用到.大家可以看过算法之后,自己去实现一下. 1.冒泡排序:大数向 ...

  3. 7种基本排序算法的Java实现

    7种基本排序算法的Java实现 转自我的Github 以下为7种基本排序算法的Java实现,以及复杂度和稳定性的相关信息. 以下为代码片段,完整的代码见Sort.java 插入排序 /** * 直接插 ...

  4. 几种简单的排序算法(JAVA)

    几种排序算法(JAVA) 一.代码 package com.hdwang; import java.util.Arrays; /** * Created by admin on 2017/1/20. ...

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

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

  6. 几大排序算法的Java实现(原创)

    几大排序算法的Java实现 更新中... 注: 该类中附有随机生成[min, max)范围不重复整数的方法,如果各位看官对此方法有什么更好的建议,欢迎提出交流. 各个算法的思路都写在该类的注释中了,同 ...

  7. 基本排序算法——冒泡排序java实现

    冒泡排序是原理最简单的一种排序算法,具体思想就不多说了,代码如下: eclipse4.3中编译通过 package sort.basic; import java.util.Arrays; publi ...

  8. 排序算法练习--JAVA(插入、直接选择、冒泡、快速排序、非递归快速排序)

    排序算法是数据结构中的经典算法知识点,也是笔试面试中经常考察的问题,平常学的不扎实笔试时候容易出洋相,回来恶补,尤其是碰到递归很可能被问到怎么用非递归实现... package sort; impor ...

  9. 排序算法(JAVA)

    import java.util.Random;      /**  * 排序测试类  *   * 排序算法的分类如下:  * 1.插入排序(直接插入排序.折半插入排序.希尔排序):  * 2.交换排 ...

  10. 常用排序算法的Java实现 - 1

    学习编程语言时, 我们会接触到许多排序算法, 这里总结了一下常见的排序算法. 不定期更新. * 其实在Java中存在如Collections.sort()这样的方法来自动为我们排序, 不过学习排序算法 ...

随机推荐

  1. 关于 iframe 在ie11 height:100% 无效的巨坑

    好的,今天公司分配了个解决ie中的bug的任务,其中,有一个就是iframe 的高度 100% 没有生效的问题: 一开始,由于我真的没有怎么去了解过iframe这个货,所以,网上各种搜索一大堆关于这货 ...

  2. shell脚本编程-使用结构化命令(if/else)(转)

    11.1 使用if-then语句 格式如下 if语句会执行if行定义的那个命令,如果该命令的退出状态码是0,则then部分的语句就会执行,其他值,则不会   1 2 3 4 if command th ...

  3. 剑指offer系列22--二叉树中和为某一值的路径

    22[题目]输入一颗二叉树和一个整数,打印出二叉树中结点值的和为输入整数的所有路径. * 路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径 * [思路]只要从根结点到叶结点一条一条遍 ...

  4. easyui dialog遮罩层

    当dialog在一个iframe里时,此dialog的遮罩层也会只覆盖这个iframe,要想覆盖整个页面,就把dialog写到最外层的父页面中去,此时dialog的遮罩层会自动覆盖整个页面,若需要从子 ...

  5. C#反射—解决类的实例化问题

    利用简单工厂模式来改进抽象工厂使用的复杂性(抽象工厂详见 设计模式之—抽象工厂模式) 数据表(User)业务处理接口(IUser) namespace FactoryMethodPatternDB.C ...

  6. windows应用中调用DLL一步步试验

    试验环境: PC:win10 build 10143 IDE: vs2015 RC WinPhone: win10 build 10136 简单界面,点按钮,算加法 一.主程用C++ 1.新建visu ...

  7. [原创]adb使用教程v1.0-----by-----使用logcat快速抓取android崩溃日志

    原文再续,书接上回:<使用logcat快速抓取android崩溃日志>中提到的工具包可以下载拉~ <使用logcat快速抓取android崩溃日志>:http://www.cn ...

  8. java 运行时常量、编译时常量、静态块执行顺序

    详见:http://blog.yemou.net/article/query/info/tytfjhfascvhzxcyt223 常量是程序运行时恒定不变的量,许多程序设计语言都有某种方法,向编译器告 ...

  9. HTTP知识点【总结篇】

    1.什么是HTTP协议? 客户端和服务器之间数据传输的格式规范.全拼:HyperText Transfer Protocol:超文本传输协议. 2.http协议是无状态协议?怎么解决无状态协议? 无状 ...

  10. qt quick-初始学习概念

    Qt Quick简介: Qt Quik 是一种高级用户界面技术,使用它可以轻松地创建供移动和嵌入式设备使用到动态触摸式界面和轻量级应用程序:Qt Quick主要由三部份组成: 改进的Qt Creato ...