//前n项阶乘分之一的和
public class jiecheng {
public static void main(String[] args)
{
double sum=0;
double j=1;
int n=10;
for(int i=1;i<=10;i++)
{
j=ji;
sum=1/j+sum;
}
Systemoutprintln("前"+n+"项阶乘的和为："+sum);
}
}
import javautilArrayList;
import javautilList;
import javautilScanner;
public class MyStack {
public static void main(String[] args) {
List<ArrayList<Integer>> listAll = new ArrayList<ArrayList<Integer>>();
Scanner scanner = new Scanner(Systemin);
// 获取第一行输入的数据
String s1 = scannernextLine();
String[] ss1 = s1split(" ");
List<Integer> listRow;
String sTemp;
String[] ssTemp;
for (int i = 0; i < IntegerparseInt(ss1[0]); i++) {
listRow = new ArrayList<Integer>();
sTemp = scannernextLine();
ssTemp = sTempsplit(" ");
for (int j = 0; j < ssTemplength; j++) {
listRowadd(IntegerparseInt(ssTemp[j]));
}
listAlladd((ArrayList<Integer>) listRow);
}
List<ArrayList<Integer>> xulie = new ArrayList<ArrayList<Integer>>();
xulie = xl(IntegerparseInt(ss1[1]));
int sum = 0;
for (int i = 0; i < listAllsize(); i++) {
sum += selectMaxRow(xulie, listAllget(i));
}
Systemoutprintln("总得分:" + sum);
}
/
算出指定数组，按照某种序列计算得分后，最大的结果
@param xulie
@param listRow
/
private static int selectMaxRow(List<ArrayList<Integer>> xulie,
List<Integer> listRow) {
int maxRow = 0;
for (int i = 0; i < xuliesize(); i++) {
if (calRow(xulieget(i), listRow) > maxRow) {
maxRow = calRow(xulieget(i), listRow);
}
}
return maxRow;
}
/
根据某种序列，计算指定数组的得分
@param listRow
@return
/
private static int calRow(List<Integer> xul, List<Integer> listRow) {
int sumRow = 0;
for (int i = 0; i < xulsize(); i++) {
sumRow += listRowget(xulget(i) - 1) abI(i + 1);
}
return sumRow;
}
/
计算2的i次方
@param i
@return
/
private static Integer abI(int abi) {
int sumi = 1;
for (int i = 0; i < abi; i++) {
sumi = 2;
}
return sumi;
}
/
对于一个m列的数组，每次取行首或者行尾，所得出的取值顺序序列一共有2^(m-1)种 exp: m=3,return: {1,2,3}
{1,3,2} {3,1,2} {3,2,1}。 返回的数组，其中各项的位置不重要
@param m
@return 返回数组的每一种取值顺序序列
/
public static List<ArrayList<Integer>> xl(int m) {
List<ArrayList<Integer>> l = new ArrayList<ArrayList<Integer>>();
ladd(new ArrayList<Integer>());
for (int i = 1; i <= m; i++) {
if (i == 1) {
lget(0)add(1);
} else {
int lsize = lsize();
for (int j = 0; j < lsize; j++) {
List<Integer> ltemp = new ArrayList<Integer>();
copy(ltemp, lget(j));
// 添加一项到数组头位置，并赋值为 1
ltempadd(0, 1);
ladd((ArrayList<Integer>) ltemp);
// 在该序列的最前面 添加 i
lget(j)add(0, i);
}
}
}
return l;
}
/
把List lf里面的值+1后 复制到ltemp中去
@param ltemp
@param lf
/
private static void copy(List<Integer> ltemp, ArrayList<Integer> lf) {
for (int i = 0; i < lfsize(); i++) {
ltempadd(lfget(i) + 1);
}
}
}
package image;
import javautilArrays;
/
10个排序
@author yugi
/
public class AllSrots
{
/
直接选择排序
/
private static void directChooseSort ( int[] array )
{
for ( int i = 0; i < arraylength; i++ )
{
int index = i;
for ( int j = i + 1; j < arraylength; j++ )
{
if (array[index] > array[j])
{
index = j;
}
}
if (i != index)
{
int temp = array[i];
array[i] = array[index];
array[index] = temp;
}
}
}
/
堆排序
/
private static void heapSort ( int[] array, int start, int len )
{
int pos = ( len - 1 ) / 2;
for ( int i = pos; i >= 0; i-- )
{
int tmp = array[start + i];
int index = i 2 + 1;
while (index < len)
{
if (index + 1 < len && array[start + index] < array[start + index + 1]) // 从小到大
{
index += 1;
}
if (tmp < array[start + index]) // 从小到大
{
array[start + i] = array[start + index];
i = index;
index = i 2 + 1;
}
else
{
break;
}
}
array[start + i] = tmp;
}
for ( int i = 0; i < len; i++ )
{
int temp = array[start];
array[start] = array[start + len - 1 - i];
array[start + len - 1 - i] = temp;
// 再一次
int post = 0;
int tmp = array[start + post];
int index = 2 post + 1;
while (index < len - 1 - i)
{
if (index + 1 < len - 1 - i && array[start + index] < array[start + index + 1]) // 从小到大
{
index += 1;
}
if (tmp < array[start + index]) // 从小到大
{
array[start + post] = array[start + index];
post = index;
index = post 2 + 1;
}
else
{
break;
}
}
array[start + post] = tmp;
}
}
/
冒泡排序
/
private static void bubbleSort ( int[] array )
{
for ( int i = 0; i < arraylength; i++ )
{
for ( int j = i + 1; j < arraylength; j++ )
{
if (array[i] > array[j])
{
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
}
/
快速排序
/
private static void quickSort ( int[] array, int start, int end )
{
if (start < end)
{
int key = array[start];
int i = start;
for ( int j = start + 1; j < end + 1; j++ )
{
if (key > array[j])
{
int temp = array[j];
array[j] = array[i + 1];
array[i + 1] = temp;
i++;
}
}
array[start] = array[i];
array[i] = key;
quickSort (array, start, i - 1);
quickSort (array, i + 1, end);
}
}
/
直接插入排序
/
private static void directInsertSort ( int[] array )
{
for ( int i = 1; i < arraylength; i++ )
{
int j;
int temp = array[i];
for ( j = i; j > 0; j-- )
{
if (array[j - 1] > temp)
{
array[j] = array[j - 1];
}
else
{
break;
}
}
array[j] = temp;
}
}
/
折半插入排序
/
private static void binaryInsertSort ( int[] array )
{
for ( int i = 1; i < arraylength; i++ )
{
// if (array[i] > array[i - 1]) // 从大到小
if (array[i] < array[i - 1]) // 从小到大
{
int tmp = array[i];
int low = 0;
int high = i - 1;
while (low <= high)
{
int mid = ( low + high ) >>> 1;
// if (array[mid] > tmp) // 从大到小
if (array[mid] < tmp)// 从小到大
{
low = mid + 1;
}
else
{
high = mid - 1;
}
}
for ( int j = i; j > low; j-- )
{
array[j] = array[j - 1];
}
array[low] = tmp;
}
}
}
/
希尔排序
/
private static void shellSort ( int[] array, int start, int len )
{
int power = 1;
while (( power + 1 ) 2 < len)
{
power = ( power + 1 ) 2 - 1;
}
for ( int k = power; k >= 1; k = ( k + 1 ) / 2 - 1 )
{
for ( int i = 0; i < k; i++ )
{
if (len - i <= 1)
{
break;
}
int tmp;
for ( int j = start + i + k; j < start + len; j += k )
{
tmp = array[j];
int m = j;
for ( ; m > start + i; m -= k )
{
if (array[m - k] > tmp) // 从小到大
{
array[m] = array[m - k];
}
else
{
break;
}
}
array[m] = tmp;
}
}
}
}
/
归并排序
/
private static void mergeSort ( int[] array, int start, int end, int[] tempArray )
{
if (end <= start)
{
return;
}
int middle = ( start + end ) / 2;
mergeSort (array, start, middle, tempArray);
mergeSort (array, middle + 1, end, tempArray);
int k = 0, leftIndex = 0, rightIndex = end - start;
Systemarraycopy (array, start, tempArray, 0, middle - start + 1);
for ( int i = 0; i < end - middle; i++ )
{
tempArray[end - start - i] = array[middle + i + 1];
}
while (k < end - start + 1)
{
if (tempArray[rightIndex] > tempArray[leftIndex]) // 从小到大
{
array[k + start] = tempArray[leftIndex++];
}
else
{
array[k + start] = tempArray[rightIndex--];
}
k++;
}
}
/
桶式排序
/
private static void bucketSort ( int[] array, int min, int max )
{
int[] tmp = new int[arraylength];
int[] buckets = new int[max - min];
for ( int i = 0; i < arraylength; i++ )
{
buckets[array[i] - min]++;
}
// 从小到大
// for ( int i = 1; i < max - min; i++ )
// {
// buckets[i] = buckets[i] + buckets[i - 1];
// }
// 从大到小
for ( int i = max - min - 1; i > 0; i-- )
{
buckets[i - 1] = buckets[i] + buckets[i - 1];
}
Systemarraycopy (array, 0, tmp, 0, arraylength);
for ( int k = arraylength - 1; k >= 0; k-- )
{
array[--buckets[tmp[k] - min]] = tmp[k];
}
}
/
基数排序
/
private static void radixSort ( int[] array, int from, int radix, int d )
{
int len = arraylength;
int[] temporary = new int[len];
int[] count = new int[radix];
int R = 1;
for ( int i = 0; i < d; i++ )
{
Systemarraycopy (array, from, temporary, 0, len);
Arraysfill (count, 0);
for ( int k = 0; k < len; k++ )
{
int subkey = ( temporary[k] / R ) % radix;
count[subkey]++;
}
// 从小到大
// for ( int j = 1; j < radix; j++ )
// {
// count[j] = count[j] + count[j - 1];
// }
// 从大到小
for ( int j = 1; j < radix; j++ )
{
count[j - 1] = count[j] + count[j - 1];
}
for ( int m = len - 1; m >= 0; m-- )
{
int subkey = ( temporary[m] / R ) % radix;
--count[subkey];
array[from + count[subkey]] = temporary[m];
}
R = radix;
}
}
public static void main ( String[] args )
{
int[] array = new int[] { 11, 213, 134, 65, 77, 78, 23, 43 };
directChooseSort (array);
Systemoutprintln (ArraystoString (array));
array = new int[] { 11, 213, 134, 65, 77, 78, 23, 43 };
heapSort (array, 0, arraylength);
Systemoutprintln (ArraystoString (array));
array = new int[] { 11, 213, 134, 65, 77, 78, 23, 43 };
bubbleSort (array);
Systemoutprintln (ArraystoString (array));
array = new int[] { 11, 213, 134, 65, 77, 78, 23, 43 };
quickSort (array, 0, arraylength - 1);
Systemoutprintln (ArraystoString (array));
array = new int[] { 11, 213, 134, 65, 77, 78, 23, 43 };
directInsertSort (array);
Systemoutprintln (ArraystoString (array));
array = new int[] { 11, 213, 134, 65, 77, 78, 23, 43 };
binaryInsertSort (array);
Systemoutprintln (ArraystoString (array));
array = new int[] { 11, 213, 134, 65, 77, 78, 23, 43 };
shellSort (array, 0, arraylength);
Systemoutprintln (ArraystoString (array));
array = new int[] { 11, 213, 134, 65, 77, 78, 23, 43 };
mergeSort (array, 0, arraylength - 1, new int[arraylength]);
Systemoutprintln (ArraystoString (array));
array = new int[] { 11, 213, 134, 65, 77, 78, 23, 43, 321 };
bucketSort (array, 11, 322);
Systemoutprintln (ArraystoString (array));
array = new int[] { 111, 213, 134, 65, 77, 78, 23, 43, 321 };
radixSort (array, 0, 2, arraylength);
Systemoutprintln (ArraystoString (array));
}
}
import javalangMath;
import javautilRandom;
/
冒泡排序
该程序先随机生成一个长度为10,并且数值在10-210之间的数组
然后通过冒泡的方法对生成的数组进行排序并从控制台输出。
/
public class SortTest {
/
升序标志
/
public static final int SHENGXU=1;
/
降序标志
/
public static final int JIANGXU=2;
/
主函数
@param args
/
public static void main(String args[]) {
SortTestexecSort(JIANGXU);
}
/
交换值，交换数组的两个值
@param array *** 作的数组
@param i 第一个
@param j 第二个
/
private static void jiaohuan(int[] array,int i, int j)
{
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
/
@param method
1为升序，2为降序
/
public static void execSort(int method) {
int[] array = null;
array = initArray(10, 210, 10);
int[] orderarray = maopao(array,method);
for (int i = 0; i < orderarraylength; i++) {
Systemoutprintln(orderarray[i]);
}
}
/
取随机数据，初始化一个数组
@param min
随机数的最小值
@param max
最大值
@param size
取得随机数的数量
@return
/
public static int[] initArray(int min, int max, int size) {
int[] init = new int[size];
for (int i = 0; i < size; i++) {
init[i] = min + (int) (Mathrandom() (max - min + 1));
Systemoutprintln(i + "-------" + init[i]);
}
return init;
}
/冒泡排序方法
原理：从最后一个开始将小的或大的逐渐冒出
@param array
@param method
@return
/
public static int[] maopao(int[] array,int method)
{
for(int i=0;i<arraylength;i++)
{
for (int j=arraylength -1 ;j>i;j--)
{
if (method==2)
{
if (array[i] < array[j])
jiaohuan(array,i,j);
}else if (method==1)
if (array[i] > array[j])
jiaohuan(array,i,j);
}
}
return array;
}
}
就好比问，汉语中常用写作方法有多少种，怎么分类。
算法按用途分,体现设计目的、有什么特点
算法按实现方式分，有递归、迭代、平行、序列、过程、确定、不确定等等
算法按设计范型分，有分治、动态、贪心、线性、图论、简化等等
作为图灵完备的语言，理论上”Java语言“可以实现所有算法。
“Java的标准库'中用了一些常用数据结构和相关算法
像apache common这样的java库中又提供了一些通用的算法
以上就是关于求 Java 一些经典例子算法全部的内容，包括:求 Java 一些经典例子算法、java算法题,要用java语言写的。、请列举您了解的一些排序算法，并用Java语言实现一个效率较高的等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）