疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java实现的集中排序算法


 

  在经典的排序算法里面,有:冒泡排序,选择排序,插入排序,希尔排序,二叉归并排序,快速排序,堆排序

  下面给出java的实现方式,不过快速排序没有搞定,研究中

  package net.itaem.sort;

  /**

  * 数组排序

  * */

  public class ArraySorted {

  /**

  * 冒泡排序(而且是简单的冒泡排序,应该属于交换排序,不属于经典的冒泡排序)

  * */

  public static void bubble(int[] source){

  if(source.length == 0 || source.length == 1) return; //无空,或者是1的情况下,不需要排序

  for(int i=0; i

  for(int j=i+1; j

  if(source[i] > source[j]){

  //交换

  int temp = source[i];

  source[i] = source[j];

  source[j] = temp;

  }

  }

  }

  }

  /**

  * 经典的冒泡排序

  * */

  public static void classicBubble(int[] source){

  if(source.length == 0 || source.length == 1) return; //无空,或者是1的情况下,不需要排序

  boolean flag = true;

  for(int i=0; i

  flag = false; //记录下下面一个循环是否有交换数据

  for(int j=source.length-1; j>i; j--){ //从后面开始,这样子可以将小的元素在每次循环中都提前

  if(source[i] > source[j]){

  //交换

  int temp = source[i];

  source[i] = source[j];

  source[j] = temp;

  flag = true;

  }

  }

  }

  }

  /**

  * 选择排序

  * 这也是一种普通的交换排序

  * */

  public static void swap(int[] source){

  if(source.length == 0 || source.length == 1) return; //无空,或者是1的情况下,不需要排序

  for(int i=0; i

  int min = i; //默认情况下,第i个元素为最小的元素

  for(int j=i+1; j

  if(source[min] > source[j]){

  min = j; //记录下

  }

  }

  if(min != i){ //如果最小元素存在,交换

  int temp = source[i];

  source[i] = source[min];

  source[min] = temp;

  }

  }

  }

  /**

  * 插入排序

  *

  * */

  public static void insert(int[] source){

  if(source.length == 0 || source.length == 1) return; //无空,或者是1的情况下,不需要排序

  int i=1, j = 0;

  for(; i

  if(source[i] < source[i-1]){

  int temp = source[i]; //记住要插入的变量

  for(j=i-1;j>=0 && source[j] > temp; j--){ //移动所有比temp大的元素,也就是要插入这个大的元素

  source[j+1] = source[j];

  }

  //插入元素

  source[++j] = temp;

  }

  }

  }

  /**

  * 堆排序

  * */

  public static void heap(int[] source){

  if(source.length == 0 || source.length == 1) return; //无空,或者是1的情况下,不需要排序

  int i = 0;

  //构建一个大顶堆

  for(i = source.length/2; i>=0; i--){

  heapAjust(source, i, source.length);

  }

  //开始排序

  for(i=source.length-1; i>=0; i--){

  swapItem(source, 0, i); //每次将最大的元素和最小的元素进行交换

  heapAjust(source, 0, i-1); //重新形成一个大顶堆

  }

  }

  //交换数据

  private static void swapItem(int[] source, int i, int j) {

  int temp = source[i];

  source[i] = source[j];

  source[j] = temp;

  }

  /**

  * 形成一颗大顶堆树

  * */

  private static void heapAjust(int[] source, int s, int length) {

  int temp = 0, j = 0;

  temp = source[s];

  for(j = 2*s; j

  if(j < length-1 && source[j] < source[j+1]){

  ++j;

  }

  if(temp >= source[j]){

  break;

  }

  source[s] = source[j];

  s = j;

  }

  source[s] = temp;

  }

  /**

  * 二叉归并排序

  * */

  public static void mergeSort(int[] source){

  if(source.length == 0 || source.length == 1) return; //无空,或者是1的情况下,不需要排序

  //归并排序

  merge0(source, 0, source.length-1);

  }

  private static void merge0(int[] source, int start, int end) {

  if(start != end){

  int middle = (start+end)/2;

  merge0(source, start, middle);

  merge0(source, middle+1, end);

  merge(source, start, middle, middle+1, end);

  }

  }

  private static void merge(int[] array, int start1, int end1, int start2,

  int end2) {

  int i=start1;//左路起始索引

  int j=start2;//右路起始索引

  int k=0;

  //归并的时候,会将两个数组数据按照大小输入到一个临时数组中

  //建立临时长度为两个子列表长度的数组

  int[] temp=new int[end2-start1+1];

  //循环遍历,按顺序找出两个表中的最小数据依次放入临时表中

  //注意此时左路和右路已经是有序的了。

  //当一路有一个小的,则会索引加1,继续喝另外一路的上次索引进行比较

  while(i<=end1&&j<=end2)

  {

  //这里确定归并的次序大小

  if(array[i]>array[j])

  temp[k++]=array[j++];

  else

  temp[k++]=array[i++];

  }

  //把剩下的元素放入临时数组中,只有一路的

  while(i<=end1)

  temp[k++]=array[i++];

  while(j<=end2)

  temp[k++]=array[j++];

  k=start1;

  for(int item:temp)

  array[k++]=item;

  }

  public static void main(String[] args) {

  int[] waitedSort = new int[5];

  waitedSort[0] = 4;

  waitedSort[1] = 1;

  waitedSort[2] = 2;

  waitedSort[3] = 5;

  waitedSort[4] = 3;

  mergeSort(waitedSort);

  //bubble(waitSorted);

  //heap(waitedSort);

  //insert(waitedSort);

  //swap(waitSorted);

  for(int i=0; i

  System.out.println(waitedSort[i]);

  }

  }

  }