「java保留排序」java中降序排列

今天给各位分享java保留排序的知识，其中也会对java中降序排列进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、请给出java几种排序方法
• 2、java保留字是什么?
• 3、JAVA中有哪几种常用的排序方法？
• 4、Java排序问题
• 5、JAVA中有哪些保留字？
• 6、java如何对String str="3,12,34,14,12"从小到大排序，不要逗号，重复的只保留一个

请给出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保留字是什么?

Java保留字是对Java编译器有特殊含义的字符串，作为编译器和程序员的一个约定，使其告诉编译器其声明的变量类型、类、方法特性等信息。按其用途划分为以下四类：

1、用于数据

有boolean、byte、char、 double、 false、float、int、long、new、short、true、void、instanceof。

2、用于语句

有break、case、 catch、 continue、 default 、do、 else、 for、 if、return、switch、try、while、 finally、 throw、this、 super。

3、用于修饰

有abstract、final、native、private、 protected、public、static、synchronized、transient、volatile。

4、用于方法、类、接口、包和异常

有class、 extends、 implements、interface、package、import、throws。

扩展资料

java保留字的举例分析

1、 goto 跳转

基本无任何作用，结构化程序设计完全不需要该语句即可完成各种流程，而且goto语句的使用往往会使程序的可读性降低。

2、const 静态

作为一个类型修饰符，使用const声明的对象不能更新，与final有些类似。

3、native 本地

java的不足除了体现在运行速度上要比传统的C++慢许多之外，还无法直接访问到操作系统底层（如系统硬件等)，为此使用native方法来扩展程序的功能。

参考资料来源：百度百科-java关键字

JAVA中有哪几种常用的排序方法？

最主要的是冒泡排序、选择排序、插入排序以及快速排序

1、冒泡排序

冒泡排序是一个比较简单的排序方法。在待排序的数列基本有序的情况下排序速度较快。若要排序的数有n个，则需要n-1轮排序，第j轮排序中，从第一个数开始，相邻两数比较，若不符合所要求的顺序，则交换两者的位置；直到第n+1-j个数为止，第一个数与第二个数比较，第二个数与第三个数比较，......，第n-j个与第n+1-j个比较，共比较n-1次。此时第n+1-j个位置上的数已经按要求排好，所以不参加以后的比较和交换操作。

例如：第一轮排序：第一个数与第二个数进行比较，若不符合要求的顺序，则交换两者的位置，否则继续进行二个数与第三个数比较......。直到完成第n-1个数与第n个数的比较。此时第n个位置上的数已经按要求排好，它不参与以后的比较和交换操作；第二轮排序：第一个数与第二个数进行比较，......直到完成第n-2个数与第n-1个数的比较；......第n-1轮排序：第一个数与第二个数进行比较，若符合所要求的顺序，则结束冒泡法排序；若不符合要求的顺序，则交换两者的位置，然后结束冒泡法排序。

共n-1轮排序处理，第j轮进行n-j次比较和至多n-j次交换。

从以上排序过程可以看出，较大的数像气泡一样向上冒，而较小的数往下沉，故称冒泡法。

public void bubbleSort(int a[])

{

int n = a.length;

for(int i=0;in-1;i++)

{

for(int j=0;jn-i-1;j++)

{

if(a[j] a[j+1])

{

int temp = a[j];

a[j] = a[j + 1];

a[j + 1] = temp;

}

}

}

}

2、选择排序

选择法的原理是先将第一个数与后面的每一个数依次比较,不断将将小的赋给第一个数,从而找出最小的,然后第二个数与后面的每一个数依次比较,从而找出第二小的,然后第三个数与后面的每一个数依次比较,从而找出第三小的.....直到找到最后一个数。

public void sort(int x[])

{

int n=x.length;

int k,t;

for(int i=0;in-1;i++)

{

k=i;

for(int j=i+1;j=n;j++)

{

if(x[j]x[k])k=j;

if(k!=i)

{

t=x[i];

x[i]=x[k];

x[k]=t;

}

}

}

}

3、插入排序

插入排序的原理是对数组中的第i个元素，认为它前面的i-1个已经排序好，然后将它插入到前面的i-1个元素中。插入排序对少量元素的排序较为有效.

public void sort(int obj[])

{

for(int j=1;jobj.length;j++)

{

int key=obj[j];

int i=j-1;

while(i=0obj[i]key)

{

obj[i+1]=obj[i];

i--;

}

obj[i+1]=key;

}

}

4、快速排序

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一次排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此大道整个数据变成有序序列。

public void quickSort(int obj[],int low,int high)

{

int i=low;

int j=high;

int keyValue=obj[i];

while(ij)

{

int temp=0;

while(ijobj[j]=keyValue)

{

j=j-1;

}

temp=obj[j];

obj[j]=obj[i];

obj[i]=temp;

while(ijobj[i]=keyValue)

{

i=i+1;

}

temp=obj[j];

obj[j]=ojb[i];

obj[i]=temp;

}

obj[i]=keyValue;

if(lowi-1)

{

quickSort(obj,low,i-1);

}

if(highi+1)

{

quickSort(obj,i+1,high);

}

}

Java排序问题

以前面试的时候做过，现在懒了，网上找了个给你参考import java.util.Iterator;

import java.util.TreeSet;

public class Sort {

private String[] b = new String[] {"1","2","2","3","4","6"};

private int n = b.length;

private boolean[] visited = new boolean[n];

private int[][] a = new int[n][n];

private String result = "";

private TreeSetString set = new TreeSetString();

public static void main(String[] args) {

new Sort().start();

}

private void start() {

// Initial the map a[][]

for (int i = 0; i n; i++) {

for (int j = 0; j n; j++) {

if (i == j) {

a[i][j] = 0;

} else {

a[i][j] = 1;

}

}

}

// 3 and 5 can not be the neighbor.

a[3][5] = 0;

a[5][3] = 0;

// Begin to depth search.

for (int i = 0; i n; i++) {

this.depthFirstSearch(i);

}

// Print result treeset.

Iterator it = set.iterator();

while (it.hasNext()) {

String string = (String) it.next();

System.out.println(string);

}

}

private void depthFirstSearch(int startIndex) {

visited[startIndex] = true;

result = result + b[startIndex];

if (result.length() == n) {

// "4" can not be the third position.

if (result.indexOf(" 4 ") != 2) {

// Filt the duplicate value.

set.add(result);

}

}

for (int j = 0; j n; j++) {

if (a[startIndex][j] == 1 visited[j] == false) {

depthFirstSearch(j);

}

}

// restore the result value and visited value after listing a node.

result = result.substring(0, result.length() - 1);

visited[startIndex] = false;

}

}

JAVA中有哪些保留字？

保留字以后可能用。 \x0d\x0a关键字现在就已经使用。\x0d\x0a\x0d\x0aJava 关键字列表 (依字母排序 共51组): \x0d\x0aabstract, assert,boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum,extends, final, finally, float, for, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while \x0d\x0aJava 保留字列表 (依字母排序 共14组) : Java保留字是指现有Java版本尚未使用 但以后版本可能会作为关键字使用。 \x0d\x0abyValue, cast, false, future, generic, inner, operator, outer, rest, true, var ， goto ，const,null

java如何对String str="3,12,34,14,12"从小到大排序，不要逗号，重复的只保留一个

整体思想就是将字符串先分割成数组，然后转换成数字进行比较，可用Set进行去重。

        // 将字符串分割成数组

        String str = "3,12,34,14,12";

        String[] strArray = str.split(",");

        // 将字符串转换成整型方便进行比较

        ListInteger list = new LinkedListInteger();

        for (String s : strArray) {

            list.add(Integer.valueOf(s.trim()));

        }

        // 将整型数组添加到Set中进行去重

        SetInteger set = new HashSetInteger();

        set.addAll(list);

        // 将整型数组进行排序

        Integer[] intArray = new Integer[set.size()];

        set.toArray(intArray);

        Arrays.sort(intArray);

        // 将整型再转回字符串

        String result = String.valueOf(intArray[0]);

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

            result = result + " " + intArray[i];

        }

关于java保留排序和java中降序排列的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。