java算法编程试题

Ⅰ 一道关于java排序算法的题目（蓝桥杯编程题）

import java.io.BufferedInputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;

public class Main
{

int re = 0;

public String doFilter()
{
//在这里我把断号和重号的初始值都设置成0，实际情况是不可能出现0的情况，所以设置成0.
int m = 0;// 表示断号
int n = 0;// 表示重号
List<String[]> list = new ArrayList<String[]>();
List<Integer> numList = new ArrayList<Integer>();
Scanner scan1 = new Scanner(System.in);
Scanner scan2 = new Scanner(new BufferedInputStream(System.in));
int rowNum = scan1.nextInt();
// 把输入所有行的数据放到numList里
for (int i = 0; i < rowNum; i++)
{
String s = scan2.nextLine().trim();
String[] nums = s.split(" ");
for (String str : nums)
{
if (str.trim().length() != 0)
{
numList.add(Integer.valueOf(str));
}
}
}
// 使用工具类对numList进行排序
Collections.sort(numList, new Comparator<Integer>()
{
@Override
public int compare(Integer a, Integer b)
{
if (a > b)
{
return 1;
}
return -1;
}
});

for (int i = 0; i < numList.size() - 1; i++)
{
//得到断号
if (numList.get(i) == numList.get(i + 1))
{
n = numList.get(i);
continue;
}
//得到重号
if ((numList.get(i) + 1) != numList.get(i + 1))
{
m = numList.get(i) + 1;
}

}

return m + " " + n;
}

public static void main(String[] args)
{
//测试下
System.out.println(new Main().doFilter());
}
}

Ⅱ JAVA编程题目，题目在补充里面

publicclassa2{

	//循环链表版的比你说的那个数组的要简单的多，功能也强大的多
		//TODOAuto-generatedmethodstub
		publicstaticvoidmain(String[]args)
		{
		intn=Integer.parseInt("50");//n为节点个数，由string数组args输入
		intm=Integer.parseInt("5");//m为报几个数
		linkedlistLL=newlinkedlist();
		
		LL.addhead(1);

		for(inti=2;i<n+1;i++)//构造循环链表
		{
		LL.addtail(i);
		}

		nodetemp=LL.head;
		while(LL.size!=0)
		{
		for(inti=0;i<m-2;i++)
		
		temp=temp.next;
		System.out.print(temp.getNext().getItem()+"->");
		
		temp.setNext(temp.getNext().getNext());
		temp=temp.next;
		LL.size--;
		}

		}

	
}

classnode//节点类
{
intno;//序列
nodenext;//下一个节点

publicnode(intno){

this(no,null);
}

publicnode(intno,nodenext)//构造方法
{
this.no=no;
this.next=next;
}
publicintgetItem(){
returnno;
}

publicvoidsetNext(nodenext){
this.next=next;
}

publicnodegetNext(){
returnnext;
}

}


classlinkedlist
{
nodehead;//头指针，尾指针
privatenodetail;
intsize;


publiclinkedlist()//构造方法，建一个空链表
{size=0;
head=tail=null;
}
publicvoidaddhead(inti)
{
head=newnode(i,head);

if(tail==null)
tail=head;
size++;
}

publicvoidaddtail(inti)
{
tail.next=newnode(i);
tail=tail.next;
tail.next=head;
size++;
}


}

Ⅲ java算法编程题

putAll(4)运行结果：
4=1+1+1+1
4=1+1+2
4=1+2+1
4=1+3
4=2+1+1
4=2+2
4=3+1
static
void
putAll(int
n)
{
for(int
i=1;i<n;i++)
{
putAllRec(n+"="+i,
n-i);
System.out.println(n+"="+i+"+"+(n-i));
}
}
static
void
putAllRec(String
prefix,
int
n)
{
for(int
i=1;i<n;i++)
{
putAllRec(prefix+"+"+i,
(n-i));
System.out.println(prefix+"+"+i+"+"+(n-i));
}
}
另外提供一个不用递归的方法，同样的输出：
static
void
putAll(int
n)
{
int[]
a
=
new
int[n];
for(int
i=0;i<n;i++)
a[i]=1;
int
w
=
n-1;
while(a[0]!=n)
{
System.out.print(n+"="+a[0]);
for(int
i=1;i<=w;i++)
System.out.print("+"+a[i]);
System.out.println();
if(a[w]==1)
{
a[w-1]++;
a[w]--;
w--;
}
else
{
a[w-1]++;
int
t
=
a[w]-1;
for(int
i=0;i<t;i++)
a[w+i]=1;
w+=(t-1);
}
}
}
再附加一个上面这个方法的“精简”版（同样输出，就是代码少点，没什么实际意义）：
static
void
putAll(int
n)
{
int[]
a
=
new
int[n];
for(int
i=0;i<n;i++)
a[i]=1;
while(a[0]!=a.length)
{
System.out.print(a.length+"="+a[0]);
for(int
i=1;i<n;i++)
System.out.print("+"+a[i]);
System.out.println();
a[n-2]++;
if(a[n-1]==1)
a[(n--)-1]--;
else
for(int
i=a[(n--)-1]-1;i>0;i--)
a[(++n)-1]=1;
}
}

Ⅳ Java算法练习题

我就直接根据你提供的数组数值来了，没有打注释，有什么不懂的可以继续追问。

public class ThreeSum {

public static void main(String[] argv) {

int a[][] = {

{ 259, 132, 799, 113 },

{ 332, 262, 209, 863 },

{ 807, 301, 684, 343 }

};

int[] b = new int[12];

int max;

int index = 0;

for ( int i = 0; i < 3; i++ ) {

for ( int j = 0; j < 4; j++ ) {

b[index++] = sum(a[i][j]);

}

}

max = b[0];

index = 0;

for ( int i = 1; i < 12; i++ ) {

if ( max < b[i] ) {

max = b[i];

index = i;

}

}

System.out.println("数字之和最大的数为: " + max);

System.out.printf("该数组的位置为: a[%d][%d] ", index / 4, index % 4);

}

public static int sum(int a) {

return (int)( ( a / 100 ) + ( ( a % 100) / 10 ) + ( a % 10 ) );

}

}

结果图如下：

Ⅳ JAVA算法题

//第一种方法
publicstaticvoidmethod1(int[]array){
		//先排序
		for(inti=0;i<array.length;i++){
			for(intj=i+1;j<array.length;j++){
				if(array[i]>array[j]){
					intc=array[i];
					array[i]=array[j];
					array[j]=c;
				}
			}
		}
		//第0位不变，2n位与2n-1位互换
		for(inti=2;i<array.length;i+=2){
			intc=array[i];
			array[i]=array[i-1];
			array[i-1]=c;
		}
	}

上面的方法先将数组排序，然后再把除0外的第2n位与2n-1位互换，这样可以保证奇数位的数总比两边的数字大，可以满足公式

	//第二种方法
	publicstaticvoidmethod2(int[]array){
		//直接按0,2,1,4,3,6,5,8,7...的顺序排序
		for(inti=0;i<array.length;i=nextIndex(i)){
			for(intj=nextIndex(i);j<array.length;j=nextIndex(j)){
				if(array[i]>array[j]){
					intc=array[i];
					array[i]=array[j];
					array[j]=c;
				}
			}
		}
	}
	
	publicstaticintnextIndex(inti){
		returni==0?i+2:(i%2==0?i-1:i+3);
	}

第二种方法在排序时直接采用除0外的第2n位与2n-1位互换的顺序排序

publicstaticvoidmain(String[]args){
		int[]array=newint[]{1,5,3,4,7,5};
		method1(array);
		for(inti=0;i<array.length;i++){
			System.out.print(i==0?"":(i%2==0?">=":"<="));
			System.out.print(array[i]);
		}
	}

结果：1<=4>=3<=5>=5<=7

虽然结果与例子不一样，但也能满足公式需求

Ⅵ 计算机java程序设计与算法试题求解

.java
解释
不执行
高级
main
声明
String
顺序、选择、循环
false
没有
90
true
静态
局部变量
Integer.parseInt()
5
break、continue、return
random.nextInt(100)
定义一个数组的引用、对数组进行初使化、数组越界
封装、继承、多态
path、classpath
可以
10
0
continue
boolean
rand.nextInt(5)
double
没有
顺序、选择、循环
System.out.println(m+1)
x定义了但没有赋值、语法
单行、多行
10
数组的引用
float
y=Integer.parseInt(x)
一个
public
public static int a()

Ⅶ java编程题,对一组{23,55,-65,89,82,99,128}中的元素从小到大进行排序

• 1. 插入排序：插入排序基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入排序的基本思想是：每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

• 2. 选择排序：选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。

• 3. 冒泡排序：冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。

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

• 5. 归并排序：归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

• 6. 希尔排序：希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

你看这个链接，网页链接

希望可以帮到你，望采纳~

Ⅷ java算法题

public class Monkey
{
public static void main(String[] args)
{
int sum=0,remain=1;
//每天吃剩的桃子加一个正好是前一天桃子的一半，每天桃子的总数就是前一天剩下桃子的数量
for(int day=9;day>=1;day--)
{
sum=(remain+1)*2;
remain=sum;
System.out.println("第"+day+"天还剩"+remain+"个桃子");
}
System.out.println(sum);
}
}