论坛首页 → Java企业应用论坛 →

各种数组排序方法总结

浏览 38087 次
锁定老帖子 主题：各种数组排序方法总结
精华帖 (0) :: 良好帖 (0) :: 新手帖 (8) :: 隐藏帖 (0)
作者 正文
  • javajack
  • 等级: 初级会员
  • 性别:
  • 文章: 10
  • 积分: 40
  • 来自: 北京
   发表时间：2008-09-05  

前一段时间面试，经常遇到有关排序的面试题，闲了无事，将各种排序方法用java写了一下。

代码如下：

import java.lang.Math;
import java.util.Random;

/**
 * 排序
 * 
 * @author javajack  
 */
public class OrderTest {

	public static void main(String args[]) {
		OrderTest.ExecOrder(2);
	}

	/**
	 * 交换值，交换数组的两个值
	 * @param array
	 * @param i
	 * @param j
	 */
	private static void swap(int[] array,int i, int j)
	{
		int tmp = array[i];
		array[i] = array[j];
		array[j] = tmp;
	}	
	
	/**
	 * 
	 * @param method
	 *            1为升序，2为降序
	 */
	public static void ExecOrder(int method) {
		int[] array = null;
		array = initArray(10, 210, 10);
		
		 //int[] orderarray = bubbleOrder(array,method);
		int[] orderarray = doubleBubbleOrder(array,method);
		//int[] orderarray = insertOrder(array, method);
		//int [] orderarray = quickOrder(array,method);
		//int[] orderarray = selectOrder(array, method);
		for (int i = 0; i < orderarray.length; i++) {
			System.out.println(orderarray[i]);
		}
	}

	/**
	 * 取随机数据，初始化一个数组
	 * 
	 * @param min
	 *            随机数的最小值
	 * @param max
	 *            最大值
	 * @param size
	 *            取得随机数的数量
	 * @return
	 */
	public static int[] initArray(int min, int max, int size) {
		int[] init = new int[size];

		for (int i = 0; i < size; i++) {
			Random ra = new Random();
			init[i] = min + (int) (Math.random() * (max - min + 1));
			System.out.println(i + "-------" + init[i]);
		}
		return init;
	}

	/**
	 * 交换排序方法
	 * 原理：依次交换值
	 * @param array
	 * @return
	 */
	public static int[] convertOrder(int[] array, int method) {
		for (int i = 0; i < array.length; i++) {
			for (int j = i + 1; j < array.length; j++) 
			{
				if (method==2)
				{
					if (array[i] < array[j]) 
						swap(array,i,j);
				}else if (method == 1) {
					if (array[i] > array[j]) 
						swap(array,i,j);
				}
			}
		}
		return array;
	}

	/**冒泡排序方法
	 * 原理：从最后一个开始将小的或大的逐渐冒出
	 * @param array
	 * @param method
	 * @return
	 */
	public static int[] bubbleOrder(int[] array,int method)
	{
		for(int i=0;i<array.length;i++)
		{
			for (int j=array.length -1 ;j>i;j--)
			{
				if (method==2)
				{
					if (array[i] < array[j])
						swap(array,i,j);
				}else if (method==1)
					if (array[i] > array[j])
						swap(array,i,j);
			}
		}
		return array;
	}
	
	/**
	 * 双向冒泡排序
	 * 原理：类似于冒泡排序，只不过是双向的
	 * @param array
	 * @param method
	 * @return
	 */
	public static int[] doubleBubbleOrder(int[] array,int method)
	{
		int left = 0;
		int right = array.length -1 ;
		while (left < right)
		{
			for(int i=left;i<=right;i++)
			{
				if (method==1)
				{
					if (array[left] > array[i])
						swap(array,left,i);
				}else
				{
					if (array[left] < array[i])
						swap(array,left,i);
				}
			}
			
			for (int i=left+1;i<=right;i++)
			{
				if (method==1)
				{
					if (array[right] < array[i])
						swap(array,right,i);
				}else
				{
					if (array[right] > array[i])
						swap(array,right,i);
					
				}
			}
			left++;
			right--;
		}
		return array;
	}
	
	/**
	 * 快速排序方法，运用到递归
	 * 排序原理：随机找到一个值，然后以此值大小进行分为两个数组，大的放左边，小的放右边，
	 * 然后再对左右两侧的数据依次排序根据
	 * @param array
	 * @param method
	 * @return
	 */
	public static int[] quickOrder(int[] array, int method) 
	{
		quickDeal(array,0,array.length - 1,method);
		return array;
	}

	/**
	 * 
	 * @param array
	 * @param begin
	 *            开始位置
	 * @param end
	 *            结束位置
	 */
	private static void quickDeal(int[] array, int begin, int end,int method) {
		if (end > begin) {
			int pos = begin + (int) (Math.random() * (end - begin + 1)); // 计算分隔位置
			int posvalue = array[pos]; // 取得分隔位置的值
			swap(array,pos,end); //将posvalue放到最end的位置
			pos=begin; //初始化pos
			for (int i=begin; i < end; i++) {
				if (method==1)
				{	
					if (array[i] < posvalue) { //当小于posvalue时，将此值移动到pos位置，也就是向前移动
						swap(array,pos,i); 
						pos++; //移动后pos增1
					}
				}else if(method == 2)
				{
					if (array[i] > posvalue) { //当小于posvalue时，将此值移动到pos位置，也就是向前移动
						swap(array,pos,i); 
						pos++; //移动后pos增1
					}
				}
			}
			swap(array,pos,end); //end位置的值前移
			quickDeal(array,begin,pos -1,method);
			quickDeal(array,pos+1,end,method);
		}

	}

	/**
	 * 插入排序方法
	 * 排序原理：抽出一个数，做为排序基序列，然后依次抽出其它数与，与此序列中的数进行比较，放入合适的位置
	 * @param array
	 * @param method
	 * @return
	 */
	public static int[] insertOrder(int[] array, int method) {

		for (int i = 1; i < array.length; i++) {
			if (method == 1) {
				if (array[i - 1] > array[i]) {
					int tmp = array[i]; //
					int j = i - 1;
					do {
						array[j + 1] = array[j];
						j--;
					} while (j >= 0 && tmp < array[j]); //当j>=0并且 当前值大于数据中j位置的值时移动
					array[j + 1] = tmp; //插入排序值
				}
			} else if (method == 2) {
				if (array[i - 1] < array[i]) {
					int tmp = array[i]; 
					int j = i - 1;
					do {
						array[j + 1] = array[j];
						j--;
					} while (j >= 0 && tmp > array[j]);
					array[j + 1] = tmp;
				}
			}
		}
		return array;
	}

	/**
	 * 选择排序方法
	 * 排序原理：每次选择一个最大的或最小的数放到已排序序列中
	 * @param array
	 * @param method
	 * @return
	 */
    public static int[] selectOrder(int[] array,int method)
    {
    	for (int i=0;i<array.length - 1;i++) 
    	{
    		int tmp = array[i];
    		int pos = i+1; //记录大值或小值的位置　
    		for (int j=i+1;j<array.length;j++)
    		{
    			if (method==1)
    			{
        			if (array[j]<tmp)
        			{
        				tmp = array[j];
        				pos= j ;//记录大值或小值的位置
        			}
    			}else if (method==2)
    			{
        			if (array[j]>tmp)
        			{
        				tmp = array[j];
        				pos= j ;//记录大值或小值的位置
        			}
    			}
    		}
    		if (tmp != array[i])
    			swap(array,i,pos); //不相同时交换
    	}
    	return array;
    }

    
}

 
返回顶楼
         
  • jjwenbo
  • 等级: 初级会员
  • 性别:
  • 文章: 4
  • 积分: 30
  • 来自: 成都
   发表时间：2008-09-09  
辛苦楼主了，不过你写的你所说的交换排序就是冒泡排序，只是一个重后开始冒泡，一个是重前开始冒泡。
你所说的交换排序：
public int[] convertOrder(int []array)
{
for(int i=0;i<array.length;i++)
{
for(int j=i+1;j<array.length;j++)
{
if(array[j-1]>array[j])
swap(array,j-1,j);
}
}
return array;
}
返回顶楼
          回帖地址
0 请登录后投票
  • alph0618
  • 等级: 初级会员
  • 性别:
  • 文章: 18
  • 积分: 30
  • 来自: 深圳
   发表时间：2008-09-10   
import java.lang.Math;
import java.util.Random;

/**
 * 排序
 * 
 * @author javajack  
 */
public class OrderTest {

	public static void main(String args[]) {
		OrderTest.ExecOrder(2);
	}

	/**
	 * 交换值，交换数组的两个值
	 * @param array
	 * @param i
	 * @param j
	 */
	private static void swap(int[] array,int i, int j)
	{
		int tmp = array[i];
		array[i] = array[j];
		array[j] = tmp;
	}	
	
	/**
	 * 
	 * @param method
	 *            1为升序，2为降序
	 */
	public static void ExecOrder(int method) {
		int[] array = null;
		array = initArray(10, 210, 10);
		
		 //int[] orderarray = bubbleOrder(array,method);
		int[] orderarray = doubleBubbleOrder(array,method);
		//int[] orderarray = insertOrder(array, method);
		//int [] orderarray = quickOrder(array,method);
		//int[] orderarray = selectOrder(array, method);
		for (int i = 0; i < orderarray.length; i++) {
			System.out.println(orderarray[i]);
		}
	}

	/**
	 * 取随机数据，初始化一个数组
	 * 
	 * @param min
	 *            随机数的最小值
	 * @param max
	 *            最大值
	 * @param size
	 *            取得随机数的数量
	 * @return
	 */
	public static int[] initArray(int min, int max, int size) {
		int[] init = new int[size];

		for (int i = 0; i < size; i++) {
			Random ra = new Random();
			init[i] = min + (int) (Math.random() * (max - min + 1));
			System.out.println(i + "-------" + init[i]);
		}
		return init;
	}

	/**
	 * 交换排序方法
	 * 原理：依次交换值
	 * @param array
	 * @return
	 */
	public static int[] convertOrder(int[] array, int method) {
		for (int i = 0; i < array.length; i++) {
			for (int j = i + 1; j < array.length; j++) 
			{
				if (method==2)
				{
					if (array[i] < array[j]) 
						swap(array,i,j);
				}else if (method == 1) {
					if (array[i] > array[j]) 
						swap(array,i,j);
				}
			}
		}
		return array;
	}

	/**冒泡排序方法
	 * 原理：从最后一个开始将小的或大的逐渐冒出
	 * @param array
	 * @param method
	 * @return
	 */
	public static int[] bubbleOrder(int[] array,int method)
	{
		for(int i=0;i<array.length;i++)
		{
			for (int j=array.length -1 ;j>i;j--)
			{
				if (method==2)
				{
					if (array[i] < array[j])
						swap(array,i,j);
				}else if (method==1)
					if (array[i] > array[j])
						swap(array,i,j);
			}
		}
		return array;
	}
	
	/**
	 * 双向冒泡排序
	 * 原理：类似于冒泡排序，只不过是双向的
	 * @param array
	 * @param method
	 * @return
	 */
	public static int[] doubleBubbleOrder(int[] array,int method)
	{
		int left = 0;
		int right = array.length -1 ;
		while (left < right)
		{
			for(int i=left;i<=right;i++)
			{
				if (method==1)
				{
					if (array[left] > array[i])
						swap(array,left,i);
				}else
				{
					if (array[left] < array[i])
						swap(array,left,i);
				}
			}
			
			for (int i=left+1;i<=right;i++)
			{
				if (method==1)
				{
					if (array[right] < array[i])
						swap(array,right,i);
				}else
				{
					if (array[right] > array[i])
						swap(array,right,i);
					
				}
			}
			left++;
			right--;
		}
		return array;
	}
	
	/**
	 * 快速排序方法，运用到递归
	 * 排序原理：随机找到一个值，然后以此值大小进行分为两个数组，大的放左边，小的放右边，
	 * 然后再对左右两侧的数据依次排序根据
	 * @param array
	 * @param method
	 * @return
	 */
	public static int[] quickOrder(int[] array, int method) 
	{
		quickDeal(array,0,array.length - 1,method);
		return array;
	}

	/**
	 * 
	 * @param array
	 * @param begin
	 *            开始位置
	 * @param end
	 *            结束位置
	 */
	private static void quickDeal(int[] array, int begin, int end,int method) {
		if (end > begin) {
			int pos = begin + (int) (Math.random() * (end - begin + 1)); // 计算分隔位置
			int posvalue = array[pos]; // 取得分隔位置的值
			swap(array,pos,end); //将posvalue放到最end的位置
			pos=begin; //初始化pos
			for (int i=begin; i < end; i++) {
				if (method==1)
				{	
					if (array[i] < posvalue) { //当小于posvalue时，将此值移动到pos位置，也就是向前移动
						swap(array,pos,i); 
						pos++; //移动后pos增1
					}
				}else if(method == 2)
				{
					if (array[i] > posvalue) { //当小于posvalue时，将此值移动到pos位置，也就是向前移动
						swap(array,pos,i); 
						pos++; //移动后pos增1
					}
				}
			}
			swap(array,pos,end); //end位置的值前移
			quickDeal(array,begin,pos -1,method);
			quickDeal(array,pos+1,end,method);
		}

	}

	/**
	 * 插入排序方法
	 * 排序原理：抽出一个数，做为排序基序列，然后依次抽出其它数与，与此序列中的数进行比较，放入合适的位置
	 * @param array
	 * @param method
	 * @return
	 */
	public static int[] insertOrder(int[] array, int method) {

		for (int i = 1; i < array.length; i++) {
			if (method == 1) {
				if (array[i - 1] > array[i]) {
					int tmp = array[i]; //
					int j = i - 1;
					do {
						array[j + 1] = array[j];
						j--;
					} while (j >= 0 && tmp < array[j]); //当j>=0并且 当前值大于数据中j位置的值时移动
					array[j + 1] = tmp; //插入排序值
				}
			} else if (method == 2) {
				if (array[i - 1] < array[i]) {
					int tmp = array[i]; 
					int j = i - 1;
					do {
						array[j + 1] = array[j];
						j--;
					} while (j >= 0 && tmp > array[j]);
					array[j + 1] = tmp;
				}
			}
		}
		return array;
	}

	/**
	 * 选择排序方法
	 * 排序原理：每次选择一个最大的或最小的数放到已排序序列中
	 * @param array
	 * @param method
	 * @return
	 */
    public static int[] selectOrder(int[] array,int method)
    {
    	for (int i=0;i<array.length - 1;i++) 
    	{
    		int tmp = array[i];
    		int pos = i+1; //记录大值或小值的位置　
    		for (int j=i+1;j<array.length;j++)
    		{
    			if (method==1)
    			{
        			if (array[j]<tmp)
        			{
        				tmp = array[j];
        				pos= j ;//记录大值或小值的位置
        			}
    			}else if (method==2)
    			{
        			if (array[j]>tmp)
        			{
        				tmp = array[j];
        				pos= j ;//记录大值或小值的位置
        			}
    			}
    		}
    		if (tmp != array[i])
    			swap(array,i,pos); //不相同时交换
    	}
    	return array;
    }

    
}

 
返回顶楼
          回帖地址
0 请登录后投票
  • javajack
  • 等级: 初级会员
  • 性别:
  • 文章: 10
  • 积分: 40
  • 来自: 北京
   发表时间：2008-09-12  
谢谢jjwenbo，当初写完后，也感觉交换排序与冒泡排序一样!
引用

public int[] convertOrder(int []array) 
{ 
for(int i=0;i<array.length;i++) 
{ 
for(int j=i+1;j<array.length;j++) 
{ 
if(array[j-1]>array[j]) 
swap(array,j-1,j); 
} 
} 
return array; 
}

不过这段程序好像有问题，试想这三个数，2，1,3,运用此法将不能排序，应该怎么样更改呢？
返回顶楼
          回帖地址
0 请登录后投票
  • flykete
  • 等级: 初级会员
  • 性别:
  • 文章: 14
  • 积分: 10
  • 来自: 北京
   发表时间：2008-09-12  
冒泡排序还能改进，
int[] a=new int[]{1,2,3,4};
boolean flag=false;
for(int i=0;i<a.length-1;i++){
if(flag==false&&i>0){
break;
}
flag=false;
for(int j=i+1;j<a.length;j++){
if(a[i]<a[j]){
int tmp=a[i];
a[i]=a[j];
a[j]=tmp;
flag=true;
}
}
}
返回顶楼
          回帖地址
0 请登录后投票
  • dust_dn
  • 等级: 初级会员
  • 性别:
  • 文章: 42
  • 积分: 30
  • 来自: 北京
   发表时间：2008-10-02  
javajack 写道
谢谢jjwenbo，当初写完后，也感觉交换排序与冒泡排序一样!
引用

public int[] convertOrder(int []array) 
{ 
for(int i=0;i<array.length;i++) 
{ 
for(int j=i+1;j<array.length;j++) 
{ 
if(array[j-1]>array[j]) 
swap(array,j-1,j); 
} 
} 
return array; 
}

不过这段程序好像有问题，试想这三个数，2，1,3,运用此法将不能排序，应该怎么样更改呢？


写得有问题。。。如果要从小到大排，前面的先不动的话，应该从后往前冒，把最小的冒泡到array[i]。。。
返回顶楼
          回帖地址
0 请登录后投票
  • chirking
  • 等级: 初级会员
  • 性别:
  • 文章: 48
  • 积分: 70
  • 来自: 大连
   发表时间：2009-06-11  
想想海量数据如何排序，比如1个1G的文件。
返回顶楼
          回帖地址
0 请登录后投票
  • sdnasky
  • 等级: 初级会员
  • 文章: 48
  • 积分: 70
  • 来自: ...
   发表时间：2009-06-15  
chirking 写道
想想海量数据如何排序，比如1个1G的文件。


分成小部分来拍,最后合并结果就可以啦
返回顶楼
          回帖地址
0 请登录后投票
  • ivyloo
  • 等级: 初级会员
  • 性别:
  • 文章: 43
  • 积分: 60
  • 来自: 成都
   发表时间：2009-06-15  
楼主是个有心人
返回顶楼
          回帖地址
0 请登录后投票
论坛首页 → Java企业应用版

跳转论坛:
Global site tag (gtag.js) - Google Analytics