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);
}
}