package qinglin.learn.arithmetic;
public class SortsServices
{
public static void main(String args[])
{
SortsServices.sortIntoAction(1);
}
/**
* 交换值,交换数组的两个值
* @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 sortIntoAction(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++)
{
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;
}
}
分享到:
相关推荐
各种排序算法各种排序算法各种排序算法各种排序算法各种排序算法各种排序算法各种排序算法
Java经典算法 ,各种排序算法 老掉牙 河內塔 費式數列 巴斯卡三角形 三色棋 老鼠走迷官(一) 老鼠走迷官(二) 騎士走棋盤 八個皇后 八枚銀幣 生命遊戲 字串核對 雙色、三色河內塔 背包問題(Knapsack...
数据结构课程中的各种排序示例完整程序,用C语言实现 各种示例包括:希尔排序、选择排序、插入排序、冒泡排序、快速排序等
各种排序算法大全c++版 冒泡,选择,快排,希尔排序,堆排序,归并排序。
各种排序算法(插入排序、冒泡排序、二叉树排序、二路归并排序,选择排序、希尔排序、快速排序、堆排序)的简单排序
基于c#的各种排序算法,基于c#的各种排序算法, 基于c#的各种排序算法,基于c#的各种排序算法, 基于c#的各种排序算法,基于c#的各种排序算法, 基于c#的各种排序算法,基于c#的各种排序算法,
各种排序方法汇总,程序事例,基础排序知识,希望有用哦
C++实现的各种排序算法的实验(源代码+实验报告),包括快速排序,堆排序等的实现
数据结构各种排序算法实现及比较 数据结构各种排序算法实现及比较 数据结构各种排序算法实现及比较
各种排序算法 JAVA代码实现 所有排序算法 JAVA代码实现
各种排序算法的实现,并通过随机生成10万个数进行算法时间效率的比较
各种排序方法汇总介绍数据结构中的经典排序,并进行比较
总结了各种排序算法,并用C++代码实现,并有演示
各种排序算法的实现
选择排序 ss_sort(int e[],int n) 直接插入排序 ss_sort(int e[],int n) 冒泡排序 sb_sort(int e[],int n) 二路合并排序 Merge(int e[],int n) 对给定的数组E[N]={213,111,222,77,400,300,987,1024,632,555} 分别...
本资源总结了在java中出现的各种排序方法
java实现的各种排序法,冒泡排序法,插入排序法,选择排序法和快速排序法,代码中还包括各种排序法效率的检验,既可以用来学习,又可以做项目是用来参考。
各种排序算法集合,快排、堆排、归并等,由c++实现,代码简短,易懂。
包含堆排序、基数排序、快速排序法、直接插入排序、直接选择排序等各种排序方法的原理及多种程序语言实现
1、链表排序 [问题描述] 建立一个...设计要求:利用随机函数产生10个样本,每个样本有20000随机整数,利用直接插入排序、希尔排序,冒泡排序、快速排序、选择排序、堆排序,归并排序,基数排序八种排序方法进行排序