您的位置:

选择排序算法的java实现(十种排序算法java)

本文目录一览:

java选择排序法

//选择排序

//原理:每次都找到当次最大的数,按大小顺序依次放入数组相应位置

//比如:第一次先找到最大的数并记下其位置,如果其不在数组第一位,

//则将其与第一位交换,使最大数置于第一位

//第二次再循环查找第二大的数并记下其位置,如果其不在数组第二位,

//则将其与第二位交换,使最大数置于第二位

//依次类推.........................................

//第i次再循环查找第i大的数并记下其位置,如果其不在数组第 i位,

//则将其与第 i位交换,使最大数置于第 i位

public class SelectSort {

public static void main(String[] args) {

int[] a = {25,15,42,16,12,36};

int max = 0;

int tmp = 0;

for(int i=0;ia.length;i++){

max = i;//

/**查找第 i大的数,直到记下第 i大数的位置***/

for(int j=i+1;ja.length;j++){

if(a[max]a[j])

max = j;//记下较大数位置,再次比较,直到最大

}

/***如果第 i大数的位置不在 i,则交换****/

if(i!=max){

tmp = a[i];

a[i] = a[max];

a[max] = tmp;

}

}

for(int i=0;ia.length;i++)

System.out.print(a[i]+" ");

}

}

不好意思哦,上次发错了,幸好楼主及时提醒,

现在再发过一次,希望您满意。

初学者:用java程序写一个选择排序算法!

选择排序法:

public class TSort{

public static void main(String args[]){

int a[]={12,45,2,5,26,56};

for(int i=0;ia.length-1;i++){

int t;

for(int j=i+1;ja.length;j++){

if(a[i]a[j]){

t=a[i];a[i]=a[j];a[j]=t;

}

}

}

for(int i=0;ia.length;i++){

System.out.print(a[i]+" ");

}

}

}

请给出java几种排序方法

java常见的排序分为:

1 插入类排序

主要就是对于一个已经有序的序列中,插入一个新的记录。它包括:直接插入排序,折半插入排序和希尔排序

2 交换类排序

这类排序的核心就是每次比较都要“交换”,在每一趟排序都会两两发生一系列的“交换”排序,但是每一趟排序都会让一个记录排序到它的最终位置上。它包括:起泡排序,快速排序

3 选择类排序

每一趟排序都从一系列数据中选择一个最大或最小的记录,将它放置到第一个或最后一个为位置交换,只有在选择后才交换,比起交换类排序,减少了交换记录的时间。属于它的排序:简单选择排序,堆排序

4 归并类排序

将两个或两个以上的有序序列合并成一个新的序列

5 基数排序

主要基于多个关键字排序的。

下面针对上面所述的算法,讲解一些常用的java代码写的算法

二 插入类排序之直接插入排序

直接插入排序,一般对于已经有序的队列排序效果好。

基本思想:每趟将一个待排序的关键字按照大小插入到已经排序好的位置上。

算法思路,从后往前先找到要插入的位置,如果小于则就交换,将元素向后移动,将要插入数据插入该位置即可。时间复杂度为O(n2),空间复杂度为O(1)

package sort.algorithm;

public class DirectInsertSort {

public static void main(String[] args) {

// TODO Auto-generated method stub

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };

int temp, j;

for (int i = 1; i data.length; i++) {

temp = data[i];

j = i - 1;

// 每次比较都是对于已经有序的

while (j = 0 data[j] temp) {

data[j + 1] = data[j];

j--;

}

data[j + 1] = temp;

}

// 输出排序好的数据

for (int k = 0; k data.length; k++) {

System.out.print(data[k] + " ");

}

}

}

三 插入类排序之折半插入排序(二分法排序)

条件:在一个已经有序的队列中,插入一个新的元素

折半插入排序记录的比较次数与初始序列无关

思想:折半插入就是首先将队列中取最小位置low和最大位置high,然后算出中间位置mid

将中间位置mid与待插入的数据data进行比较,

如果mid大于data,则就表示插入的数据在mid的左边,high=mid-1;

如果mid小于data,则就表示插入的数据在mid的右边,low=mid+1

最后整体进行右移操作。

时间复杂度O(n2),空间复杂度O(1)

package sort.algorithm;

//折半插入排序

public class HalfInsertSort {

public static void main(String[] args) {

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };

// 存放临时要插入的元素数据

int temp;

int low, mid, high;

for (int i = 1; i data.length; i++) {

temp = data[i];

// 在待插入排序的序号之前进行折半插入

low = 0;

high = i - 1;

while (low = high) {

mid = (low + high) / 2;

if (temp data[mid])

high = mid - 1;

else

// low=high的时候也就是找到了要插入的位置,

// 此时进入循环中,将low加1,则就是要插入的位置了

low = mid + 1;

}

// 找到了要插入的位置,从该位置一直到插入数据的位置之间数据向后移动

for (int j = i; j = low + 1; j--)

data[j] = data[j - 1];

// low已经代表了要插入的位置了

data[low] = temp;

}

for (int k = 0; k data.length; k++) {

System.out.print(data[k] + " ");

}

}

}

四 插入类排序之希尔排序

希尔排序,也叫缩小增量排序,目的就是尽可能的减少交换次数,每一个组内最后都是有序的。

将待续按照某一种规则分为几个子序列,不断缩小规则,最后用一个直接插入排序合成

空间复杂度为O(1),时间复杂度为O(nlog2n)

算法先将要排序的一组数按某个增量d(n/2,n为要排序数的个数)分成若干组,每组中记录的下标相差d.对每组中全部元素进行直接插入排序,然后再用一个较小的增量(d/2)对它进行分组,在每组中再进行直接插入排序。当增量减到1时,进行直接插入排序后,排序完成。

package sort.algorithm;

public class ShellSort {

public static void main(String[] args) {

int a[] = { 1, 54, 6, 3, 78, 34, 12, 45, 56, 100 };

double d1 = a.length;

int temp = 0;

while (true)

{

//利用这个在将组内倍数减小

//这里依次为5,3,2,1

d1 = Math.ceil(d1 / 2);

//d为增量每个分组之间索引的增量

int d = (int) d1;

//每个分组内部排序

for (int x = 0; x d; x++)

{

//组内利用直接插入排序

for (int i = x + d; i a.length; i += d) {

int j = i - d;

temp = a[i];

for (; j = 0 temp a[j]; j -= d) {

a[j + d] = a[j];

}

a[j + d] = temp;

}

}

if (d == 1)

break;

}

for (int i = 0; i a.length; i++)

System.out.print(a[i]+" ");

}

}

五 交换类排序之冒泡排序

交换类排序核心就是每次比较都要进行交换

冒泡排序:是一种交换排序

每一趟比较相邻的元素,较若大小不同则就会发生交换,每一趟排序都能将一个元素放到它最终的位置!每一趟就进行比较。

时间复杂度O(n2),空间复杂度O(1)

package sort.algorithm;

//冒泡排序:是一种交换排序

public class BubbleSort {

// 按照递增顺序排序

public static void main(String[] args) {

// TODO Auto-generated method stub

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20, 13, 100, 37, 16 };

int temp = 0;

// 排序的比较趟数,每一趟都会将剩余最大数放在最后面

for (int i = 0; i data.length - 1; i++) {

// 每一趟从开始进行比较,将该元素与其余的元素进行比较

for (int j = 0; j data.length - 1; j++) {

if (data[j] data[j + 1]) {

temp = data[j];

data[j] = data[j + 1];

data[j + 1] = temp;

}

}

}

for (int i = 0; i data.length; i++)

System.out.print(data[i] + " ");

}

}

java选择排序

你是想要帮你完善一下,然后可以运行是吧??

代码如下:

public class Test {

public void sortFistname(String[] args) {

String temp;

System.out.println("按首字母排序");

for (int i = 0; i  args.length - 1; i++) {

int maxIndex = i;

String max = args[i];

for (int j = i + 1; j  args.length; j++) {

int a = max.compareTo(args[j]);

if (a  0) {

maxIndex = j;

}

}

if (maxIndex != i) {

temp = args[i];

args[i] = args[maxIndex];

args[maxIndex] = temp;

}

}

for(int i=0;iargs.length;i++) {

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

}

}

public Test() {

String[] args = {"abc","afew","ebwe","gverg","nrgerg"};

sortFistname(args);

}

public static void main(String[] args) {

new Test();

}

}

Java数组排序 几种排序方法详细一点

JAVA中在运用数组进行排序功能时,一般有四种方法:快速排序法、冒泡法、选择排序法、插入排序法。

快速排序法主要是运用了Arrays中的一个方法Arrays.sort()实现。

冒泡法是运用遍历数组进行比较,通过不断的比较将最小值或者最大值一个一个的遍历出来。

选择排序法是将数组的第一个数据作为最大或者最小的值,然后通过比较循环,输出有序的数组。

插入排序是选择一个数组中的数据,通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。

1利用Arrays带有的排序方法快速排序

public class Test2{   

        public static void main(String[] args){   

                int[] a={5,4,2,4,9,1};   

                Arrays.sort(a);  //进行排序   

                for(int i: a){   

                        System.out.print(i);   

               }  

        }  

}

2冒泡排序算法

public static int[] bubbleSort(int[] args){//冒泡排序算法   

        for(int i=0;iargs.length-1;i++){   

               for(int j=i+1;jargs.length;j++){   

                   if (args[i]args[j]){   

                       int temp=args[i];   

                       args[i]=args[j];   

                       args[j]=temp;   

                       }   

            }  

       }  

       return args;  

}

3选择排序算法

public static int[] selectSort(int[] args){//选择排序算法   

         for (int i=0;iargs.length-1 ;i++ ){   

                int min=i;   

                for (int j=i+1;jargs.length ;j++ ){   

                      if (args[min]args[j]){   

                           min=j;   

                           }   

                  }   

                      if (min!=i){  

                      int temp=args[i];  

                      args[i]=args[min];  

                      args[min]=temp;          

                  }  

            }  

             return args;  

    }

4插入排序算法

public static int[] insertSort(int[] args){//插入排序算法   

                 for(int i=1;iargs.length;i++){   

                         for(int j=i;j0;j--){   

                                 if (args[j]args[j-1]){   

                                         int temp=args[j-1];  

                                         args[j-1]=args[j];  

                                        args[j]=temp;          

                                }else break;   

                        }  

                 }  

                 return args;  

         }