/**
* 打印九九乘法口诀表
*/
public static void nineNineMulitTable(){
for (int i = 1,j = 1; j <= 9; i++) {
System.out.print(i+"*"+j+"="+i*j+" ");
if(i==j){
i=0;
j++;
System.out.println();
}
}
}
/**
* * 将某个日期以固定格式转化成字符串 *
* @param date * @return str
* */
public String date2FormatStr(Date date)
{
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = sdf.format(date);
return str;
}
/**
* 判断任意一个整数是否素数
* @param num
* @return boolean
*/
public static boolean isPrimeNumber(int num)
{
for (int i = 2; i <= Math.sqrt(num); i++) {
if(num%i==0)
{
System.out.println("不是素数");
return false;
}
}
System.out.println("是素数");
return true;
} /**
* *获得任意一个整数的阶乘 *
* @param n *@returnn!
* */
public static int factorial(int num)
{
//递归
if(num == 1)
{
return 1;
}
return num*factorial(num-1);
}
/** *二分查找特定整数在整型数组中的位置(递归)
* *@param dataset
* *@param data
* *@param beginIndex
* *@param endIndex
* *@return index
* */
public static int binarySearch(int[] dataset,int data,int beginIndex,int endIndex)
{
int midIndex = (beginIndex+endIndex)/2; //如果查找的数要比开始索引的数据要小或者是比结束索引的书要大，或者开始查找的索引值大于结束的索引值返回-1没有查到
if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex)
{
return -1;
}
if(data <dataset[midIndex])
{
return binarySearch(dataset,data,beginIndex,midIndex-1);
}
else if(data>dataset[midIndex])
{
return binarySearch(dataset,data,midIndex+1,endIndex);
}else
{ return midIndex;
}
}
/** *二分查找特定整数在整型数组中的位置(非递归) *
* @param dataset *
* @param data *
* @return index
* */
public static int binarySearch(int[] dataset ,int data)
{
int beginIndex = 0;
int endIndex = dataset.length - 1;
int midIndex = -1;
if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex)
{
return -1;
}
while(beginIndex <= endIndex)
{
midIndex = (beginIndex+endIndex)/2;
if(data <dataset[midIndex])
{
endIndex = midIndex-1;
}
else if(data>dataset[midIndex])
{
beginIndex = midIndex+1;
}else
{
return midIndex;
}
}
return -1;
}
/**
* 冒泡排序
* @param dataset *
* @param data *
* @return index
* */
public static void maopaoPrint(int[] before){
String result = "" ;
for (int i = 0; i < before.length; i++) {
result +=before[i]+" ";
}
System.out.println(result);
}
public static void maopaoSort(int[] arrys){
int temp = 0;
for (int j = 0; j < arrys.length; j++) {
for (int k = 0; k < arrys.length-j-1; k++) {
if(arrys[k] > arrys[k+1]){
temp = arrys[k];
arrys[k]= arrys[k+1];
arrys[k+1]=temp;
}
}
}
maopaoPrint(arrys);
}
/**
* 快速排序1
* @param pData
* @param pDataNum
* @param left
* @param right
* */
public static void QuickSort(String[] pData,int[] pDataNum,int left,int right)
{
int i,j;
int iTemp;
String middle,strTemp;
i = left;
j = right;
middle = pData[(left+right)/2];
do{
while((pData[i].compareTo(middle)<0) && (i<right))
i++;
while((pData[j].compareTo(middle))>0 && (j>left))
j--;
if(i<=j)
{
strTemp = pData[i];
pData[i] = pData[j];
pData[j] = strTemp;
iTemp = pDataNum[i];
pDataNum[i] = pDataNum[j];
pDataNum[j] = iTemp;
i++;
j--;
}
}while(i<=j);//如果两边扫描的下标交错，就停止（完成一次）
if(left<j)
QuickSort(pData,pDataNum,left,j);
if(right>i)
QuickSort(pData,pDataNum,i,right);
}
/**
* 快排2
*
* */
public static void quickSort(int[] array) {
quickSort(array, 0, array.length - 1);
} private static void quickSort(int[] array, int low, int high) {
if (low < high) {
int p = partition(array, low, high);
quickSort(array, low, p - 1);
quickSort(array, p + 1, high);
} } private static int partition(int[] array, int low, int high) {
int s = array[high];
int i = low - 1;
for (int j = low; j < high; j++) {
if (array[j] < s) {
i++;
swap(array, i, j);
}
}
swap(array, ++i, high);
return i;
}
//掉位方法
private static void swap(int[] array, int i, int j) {
int temp;
temp = array[i];
array[i] = array[j];
array[j] = temp;
} /**
*插入排序(WHILE循环实现)
*插入排序的基本思想是，经过i-1遍处理后,L[1..i-1]己排好序。
*第i遍处理仅将L[i]插入L[1..i-1]的适当位置，使得L[1..i]又是排好序的序列。
*要达到这个目的，我们可以用顺序比较的方法。首先比较L[i]和L[i-1]，如果L[i-1]≤ L[i]騆[1..i]
*已排好序，第i遍处理就结束了；否则交换L[i]与L[i-1]的位置，继续比较L[i-1]和L[i-2]，
*直到找到某一个位置j(1≤j≤i-1)，使得L[j] ≤L[j+1]时为止。
*简言之,插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，
*直到全部插入完毕。插入排序方法分直接插入排序和折半插入排序两种，这里只介绍直接插入排序，
*折半插入排序留到“查找”内容中进行。
*图1演示了对4个元素进行直接插入排序的过程，共需要(a),(b),(c)三次插入。
*@paramsrc待排序数组
*/
public static void doInsertSort1(int[] src)
{
int len=src.length;
for(int i=1;i<len;i++)
{
int temp=src[i];
int j=i;
while(src[j-1]>temp)
{
src[j]=src[j-1];
j--;
if(j<=0)
break;
}
src[j]=temp;
printResult(i+1,src);
}
}
/**
*插入排序(FOR循环实现)
*@paramsrc待排序数组
*/
public static void doInsertSort2(int[] src)
{
int len=src.length;
for(int i=1;i<len;i++)
{
int j;
int temp=src[i];
for(j=i;j>0;j--)
{
if(src[j-1]>temp)
{
src[j]=src[j-1];
}else//如果当前的数，不小前面的数，那就说明不小于前面所有的数，
//因为前面已经是排好了序的，所以直接通出当前一轮的比较
break;
}
src[j]=temp;
printResult(i,src);
}
}
解决方案 »
- 关于设置字体的一些疑问
- 如何分析一个网页的HTML源码？
- java中关于继承层次中的方法覆盖！！谢谢
- FTPClient访问linux的vsftp看不到文件
- 能不能实现这样一个功能：把一个对象加入到Hash表或其他的集合类中，当有多个线程从集合类中取出对象后，这些线程对 对象的写操作自动被串行化（非并发）？
- 关于打包的问题 这个程序打包后还是运行不起啊
- linux的JDK的配置??急 成功就揭贴
- 怎么减慢我的机器的速度？
- Linux(RH9)下安装 eclipse-SDK-2.0.1-linux-gtk，安装完成后无法新建project，内详!
- 请教关于线程间分配时间的问题
- 帮忙看下这个基础题，代码编译出错，不知哪里出错了
- synchronized同步线程问题
{
for (int i = 2; i <= Math.sqrt(num); i++) {
if(num%i==0)
{
System.out.println("不是素数");
return false;
}
}
System.out.println("是素数");
return true;
} 我先来指正一下哪些地方不对，Math.sqrt(num)不能在每个循环都算一遍，这个很影响效率。应该拿到循环外面一次性计算出结果，如： public static boolean isPrimeNumber(int num)
{
long sqrtNum = Math.sqrt(num);
for (int i = 2; i <=sqrtNum; i++) {
.....
}
}
还有，应该先判断是否是偶数，如果不是偶数，就要在判断时候直接跳过所有偶数因子，如： public static boolean isPrimeNumber(int num)
{
if(num%2!=0){
long sqrtNum = Math.sqrt(num);
for (int i = 3; i <=sqrtNum; i=i+2) {
.....
}
}
}
其实，还有很多要优化的，比如，3判断过了，6,9,15之类的就不用判断了......
算法不光是要考虑功能实现，但更要注重效率。
求阶乘的那个,能不用递归就不要用递归,递归的效率是非常低的.支持三楼.
传一个负数就不用说了.
1.n个元素最应该是n-1趟冒泡,但给出程序却用了n次冒泡.
2.如果某趟冒泡排序过程中,没有发生过元素交换,说明排序已经完成.不需要再冒泡下去了.
最极端的例子就是,如果数组里的元素已经是有序的了,只要经过一趟冒泡就可以了.