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

内部排序:

插入排序:直接插入排序

选择排序:直接选择排序

交换排序:冒泡排序,改进的冒泡排序;快速排序,非递归实现快速排序

//堆排序:。。。

//归并排序:。。。

 import java.util.Stack;

 public class SortTest {

     /**
* 插入排序:假定指针所指数据之前的序列为有序,所要做的便是将之后的数据插入到之前的有序序列中,
            具体做法是从后往前比较指针前序列与指针所指数据的大小,如果前者大于后者,则将前者后移一
            位(也可以将其与前面一位交换),在向前比较,直至前者不大于前者,此时插入数据。
* @param a
*/
public static void insertSort(int[] a){
if(a!=null){
int temp,j;
for(int i=1;i<a.length;i++){
temp = a[i];
j=i;
if(a[j-1]>temp){
while(j>=1&&a[j-1]>temp){
a[j] = a[j-1];
j--;
}
a[j] = temp;
}
}
}
} /**
* 直接选择排序
* @param a
*/
public static void selectSort(int[] a){
int i,j;
int temp = 0;
int flag = 0;
int n = a.length;
for(i=0;i<n;i++){
temp = a[i];
flag = i;
for(j=i+1;j<n;j++){
if(a[j]<temp){
temp = a[j];
flag = j;
}
}
if(flag!=i){
a[flag] = a[i];
a[i] = temp;
}
}
} /**
* 冒泡排序
* @param a
*/
public static void bubbleSort(int[] a){
int i,j;
int len = a.length;
int tmp;
for(i=0;i<len;i++){
for(j=0;j<len-i-1;j++){
if(a[j+1]<a[j]){
tmp = a[j];
a[j] = a[j+1];
a[j+1] = tmp;
}
}
} }
/**
* 改进冒泡
* @param arr
*/
public void EffectBubbleSort(int[] arr, int low, int high){
int i,j;
boolean flag = true;
//ture表明上一趟有交换,如果为false表明无交换已经有序,停止循环
for(i=low; i<high && flag; i++){
flag = false;
for(j=high-1; j>=i; j--){
if(arr[j-1]>arr[j]){
int temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
flag = true;
}
}
}
}
/**
* 快速排序:
* 通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都小,
* 然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
* @param a
* @param low
* @param high
*/
public static void sort(int[] a, int low, int high){
int i,j;
int index;
if(low>=high)
return;
i = low;
j = high;
index = a[i];
while(i<j){
while(i<j&&a[j]>=index)
j--;
if(i<j)
a[i++] = a[j];
while(i<j&&a[i]<index)
i++;
if(i<j)
a[j--] = a[i]; }
a[i] = index;
sort(a, low, i-1);
sort(a, i+1, high);
}
/**
* 快速排序另一种实现,
* @param a
* @param start
* @param end
*/
public static void qsort(int data[], int start, int end) {
if (end <= start) {
return;
}
int last = start;
for (int i = start + 1; i <= end; i++) {
if (data[i] < data[start]) {
int temp = data[++last];
data[last] = data[i];
data[i] = temp;
}
}
int temp = data[last];
data[last] = data[start];
data[start] = temp;
sort(data, start, last - 1);
sort(data, last + 1, end);
}
/**
* 快速排序非递归,参考
* @param array
* @author http://computerdragon.blog.51cto.com/6235984/1305987
*/
public void quicksort(int[] array) {
if (array == null || array.length == 1) return;
//存放开始与结束索引
Stack<Integer> s = new Stack<Integer>();
//压栈
s.push(0);
s.push(array.length - 1);
//利用循环里实现
while (!s.empty()) {
int right = s.pop();
int left = s.pop();
//如果最大索引小于等于左边索引,说明结束了
if (right <= left) continue; int i = partition(array, left, right);
if (left < i - 1) {
s.push(left);
s.push(i - 1);
}
if (i + 1 < right) {
s.push(i+1);
s.push(right);
}
}
}
//找到轴心,进行交换,上面qsort()中扫描交换的实现也可行
public int partition (int[] data, int first, int end)
{
int temp;
int i=first,j=end;
if(first<end)
{
temp=data[i];
//当i=j的时候,则说明扫描完成了
while(i<j)
{
//从右边向左边扫描找到一个小于temp的元素
while(j>i&&data[j]>temp)j--;
if(i<j)
{
//将该元素赋值给temp
data[i]=data[j];
//赋值后就应该将i+1指向下一个序号
i++;
} //然后从左边向右边开始扫描,找到一个大于temp的元素
while(i<j&&temp>data[i])i++;
if(i<j)
{
//将该元素赋值给temp
data[j]=data[i];
//赋值后就应该将j-1指向前一个序号
j--;
}
}
//将轴数据放在i位置中
data[i]=temp;
}
return i; }   

排序算法练习--JAVA(插入、直接选择、冒泡、快速排序、非递归快速排序)的更多相关文章

  1. 必须知道的八大种排序算法【java实现】(一) 冒泡排序、快速排序

    冒泡排序 冒泡排序是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个 ...

  2. 排序算法练习--JAVA(:内部排序:插入、选择、冒泡、快速排序)

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

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

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

  4. 一文搞定十大经典排序算法(Java实现)

    本文总结十大经典排序算法及变形,并提供Java实现. 参考文章: 十大经典排序算法总结(Java语言实现) 快速排序算法—左右指针法,挖坑法,前后指针法,递归和非递归 快速排序及优化(三路划分等) 一 ...

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

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

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

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

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

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

  8. 常用排序算法及Java实现

    概述 在计算器科学与数学中,一个排序算法(英语:Sorting algorithm)是一种能将一串数据依照特定排序方式进行排列的一种算法.本文将总结几类常用的排序算法,包括冒泡排序.选择排序.插入排序 ...

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

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

随机推荐

  1. play(1) 第一个简单的应用

    去年去了一家公司,公司要求要回使用play,所以在几天的时间内猛学习了一段时间play,发现play!有很多优点:简单,小巧,高开发效率,集成很多功能,容易调试.现在虽然已经不在那家公司,没有使用pl ...

  2. 使用JavaScript的history对象来实现页面前进后退(go/back/forward)。

    我们都知道JavaScript有history对象,主要是用来记录浏览器窗口的浏览记录.但是,JS脚本是不允许访问到这个记录里面的内容(隐私). 常见的用法是: history.back();//返回 ...

  3. net之工作流工程展示及代码分享(记录)

    http://www.cnblogs.com/thanks/p/4183235.html

  4. git clone错误

    git clone错误 Initialized empty Git repository in ***/.git/ error: The requested URL returned error: 4 ...

  5. leetcode Online Judge 150题 解答分析之一 Reverse Words in a String

    问题 Given an input string, reverse the string word by word. For example, Given s = "the sky is b ...

  6. Fragment之间的通信(四)

    自定义两个fragment的布局和java类. 在mainactivity中引用布局文件 在其中的一个fragment中的控件上添加监听,获取到另一个fragment中控件的内容,展示出来完成frag ...

  7. Eclipse 搭建 Maven Web项目

    第一步:安装JDK: 第二步:安装Eclipse: 第三步:安装tomcat7: 第四步:安装maven插件: 4.1 下载maven:http://maven.apache.org/download ...

  8. HTML之iframe

    iframe:是框架的一种形式. 属性: frameborder=0/1 表示是否显示周围边框 0--否 1--是 width,height:设置的边框宽高,具体数值不需要加单位,也可用百分比 mar ...

  9. fatal: Could not read from remote repository.的解决办法

    1. git remote –v查看远端地址或者查看配置 git config –list 2. git status 3. git add . git status git commit -m “本 ...

  10. Maven构件解析(转)

    文章转自http://gavinwind2000.iteye.com/blog/2290652 谢谢博主的总结! 在Maven中,任何一个依赖.插件或者项目构建的输出,都可以称之为构件. Maven在 ...