排序算法

思想一：试除法
要判断X是否为质数，就从2一直尝试到x-1的做法效率是最差的！ 其实只要从2一直尝试到√x，就可以了。因为因数都是成对出现的。比如，100的因数有：1和100，2和50，4和25，5和20，10和10。看出来没有？成对的因数，其中一个必然小于等于100的开平方，另一个大于等于100的开平方

package com.ying.keepup;

import java.util.Scanner;

public class suShu {
public static void main(String[] args) {
boolean flag;
System.out.println("请输入m:");
Scanner sc = new Scanner(System.in);
int m=sc.nextInt();
// 从2开始一直循环到m
for(int i=2;i<m;i++){
flag=false;
for(int j=2;j<=Math.sqrt(i);j++){
if(i%j==0){
flag=true; //如果有一个数除得断则这个数就不是质数
break;
}
}
// 所有的都除不断后就是质数 所以输出
if(flag==false){
System.out.print(i+" ");
}
}
}
}

 
/**
     * 这次算法用了StringBuffer效率更好
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        System.out.println("请输入要转换的十进制的数：");
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();        
        System.out.println("转换的十六进制的数为："+intToHex(n));
    }

    private static String intToHex(int n) {
        StringBuffer s = new StringBuffer();
        String a;
        char []b = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
        while(n != 0){
            s = s.append(b[n%16]);
            n = n/16;            
        }
        a = s.reverse().toString();
        return a;
    }

package com.llh.demo;

import java.util.Scanner;

/**
*
* @author llh
*
*/
public class Test {
/*
* 将任意一个十进制数数字转换为二进制形式，并输出转换后的结果（使用数组存储）
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个十进制数：");
int number = sc.nextInt();
System.out.println("该数的二进制数值为:");
int sum;
String result = "";
for (int i = number; i >= 1; i = i / 2) {
if (i % 2 == 0) {
sum = 0;
} else {
sum = 1;
}
result = sum + result;
}
System.out.print(result);
}

}

https://www.cnblogs.com/guoyaohua/p/8600214.html

/**
* 冒泡排序
*
* @param array
* @return
*/
public static int[] bubbleSort(int[] array) {
if (array.length == 0)
return array;
for (int i = 0; i < array.length; i++)
for (int j = 0; j < array.length - 1 - i; j++)
if (array[j + 1] < array[j]) {
int temp = array[j + 1];
array[j + 1] = array[j];
array[j] = temp;
}
return array;
}

/**
* 快速排序方法
* @param array
* @param start
* @param end
* @return
*/
public static int[] QuickSort(int[] array, int start, int end) {
if (array.length < 1 || start < 0 || end >= array.length || start > end) return null;
int smallIndex = partition(array, start, end);
if (smallIndex > start)
QuickSort(array, start, smallIndex - 1);
if (smallIndex < end)
QuickSort(array, smallIndex + 1, end);
return array;
}
/**
* 快速排序算法——partition

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
* @param array
* @param start
* @param end
* @return
*/
public static int partition(int[] array, int start, int end) {
int pivot = (int) (start + Math.random() * (end - start + 1));
int smallIndex = start - 1;
swap(array, pivot, end);
for (int i = start; i <= end; i++)
if (array[i] <= array[end]) {
smallIndex++;
if (i > smallIndex)
swap(array, i, smallIndex);
}
return smallIndex;
}

/**
* 交换数组内两个元素
* @param array
* @param i
* @param j
*/
public static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}

https://blog.csdn.net/qq_26122557/article/details/79458649

详解：https://blog.csdn.net/elma_tww/article/details/86164674