import java.util.*;
import java.io.*;node
public class SortAlgorithm
{
static Random rand = new Random();算法
void bubbleSort(int[] numlist) // 冒泡排序算法
{
int temp;
for(int j=1;j<numlist.length;j++)
for(int i=0;i<numlist.length-j;i++)
if(numlist>numlist[i+1])
{
temp = numlist[i+1];
numlist[i+1] = numlist;
numlist = temp;
}
}數組
void selectionSort (int[] numlist) //選擇排序算法
{
int temp;
for(int i=0;i<numlist.length-1;i++)
for(int j=i+1;j<numlist.length;j++)
if(numlist>numlist[j])
{
temp = numlist[j];
numlist[j] = numlist;
numlist = temp;dom
}
}函數
void insertSort (int[] numlist) //插入排序算法
{
int temp,in,out;
for(out=1;out<numlist.length;out++)
{
temp=numlist[out];
in=out;
while(in>0 && numlist[in-1]>=temp)
{
numlist[in]=numlist[in-1];
--in;
}
numlist[in]=temp;
}this
}url
void display (int[] num) // 打印出排序結果
{
for(int i = 0;i<num.length;i++)
System.out.print(num+" ");
System.out.println("");.net
}rest
static int pRand(int mod) // 生成隨即數組
{
return Math.abs(rand.nextInt())%mod;
}
public static void main(String args[])throws IOException
{
SortAlgorithm sortAlgorithm = new SortAlgorithm();
int[] numList = new int[10];
for(int i = 0;i<numList.length;i++)
numList = pRand(100); //調用pRand方法，把隨即生成的數據輸入到
// 數組中
System.out.println("隨即生成的數組是：");
// 打印出原數組，
for(int j =0;j<numList.length;j++)
System.out.print(numList[j]+" ");
System.out.println("");
long begin = System.currentTimeMillis(); //排序開始時間，調用系統的當前時間
sortAlgorithm.bubbleSort(numList); //執行冒泡排序
long end = System.currentTimeMillis(); //排序結束時間，調用系統當前時間
System.out.println("冒泡排序用時爲：" + (end-begin)); //排序用時
System.out.println("排序後的數組爲：");
sortAlgorithm.display(numList);
begin = System.currentTimeMillis();
sortAlgorithm.selectionSort(numList);
end = System.currentTimeMillis();
System.out.println("選擇排序用時爲：" +(end-begin));
System.out.println("排序後的數組爲：");
sortAlgorithm.display(numList);
begin = System.currentTimeMillis();
sortAlgorithm.insertSort(numList);
end = System.currentTimeMillis();
System.out.println("插入排序用時爲：" + (end-begin));
System.out.println("排序後的數組爲：");
sortAlgorithm.display(numList);
}
}
題目以下：用一、二、二、三、四、5這六個數字，用java寫一個main函數，打印出全部不一樣的排列，如：51223四、412345等，要求："4"不能在第三位，"3"與"5"不能相連。
static int[] bits = new int[] { 1, 2, 3, 4, 5 };
/**
* @param args
*/
public static void main(String[] args) {
sort("", bits);
}
private static void sort(String prefix, int[] a) {
if (a.length == 1) {
System.out.println(prefix + a[0]);
}
for (int i = 0; i < a.length; i++) {
sort(prefix + a, copy(a, i));
}
}
private static int[] copy(int[] a,int index){
int[] b = new int[a.length-1];
System.arraycopy(a, 0, b, 0, index);
System.arraycopy(a, index+1, b, index, a.length-index-1);
return b;
}
**********************************************************************
基本思路：
1 把問題歸結爲圖結構的遍歷問題。實際上6個數字就是六個結點，把六個結點鏈接成無向連通圖，對於每個結點求這個圖形的遍歷路徑，全部結點的遍歷路徑就是最後對這6個數字的排列組合結果集。
2 顯然這個結果集還未達到題目的要求。從如下幾個方面考慮：
1. 3，5不能相連：實際要求這個連通圖的結點3，5之間不能連通, 可在構造圖結構時就知足改條件，而後再遍歷圖。
2. 不能有重複: 考慮到有兩個2，明顯會存在重複結果，能夠把結果集放在TreeSet中過濾重複結果
3. 4不能在第三位: 仍舊在結果集中去除知足此條件的結果。
採用二維數組定義圖結構，最後的代碼是：
import java.util.Iterator;
import java.util.TreeSet;
public class TestQuestion {
private String[] b = new String[]{"1", "2", "2", "3", "4", "5"};
private int n = b.length;
private boolean[] visited = new boolean[n];
private int[][] a = new int[n][n];
private String result = "";
private TreeSet set = new TreeSet();
public static void main(String[] args) {
new TestQuestion().start();
}
private void start() {
// Initial the map a[][]
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) {
a[j] = 0;
} else {
a[j] = 1;
}
}
}
// 3 and 5 can not be the neighbor.
a[3][5] = 0;
a[5][3] = 0;
// Begin to depth search.
for (int i = 0; i < n; i++) {
this.depthFirstSearch(i);
}
// Print result treeset.
Iterator it = set.iterator();
while (it.hasNext()) {
String string = (String) it.next();
// "4" can not be the third position.
if (string.indexOf("4") != 2) {
System.out.println(string);
}
}
}
private void depthFirstSearch(int startIndex) {
visited[startIndex] = true;
result = result + b[startIndex];
if (result.length() == n) {
// Filt the duplicate value.
set.add(result);
}
for(int j = 0; j < n; j++) {
if (a[startIndex][j] == 1 && visited[j] == false) {
depthFirstSearch(j);
} else {
continue;
}
}
// restore the result value and visited value after listing a node.
result = result.substring(0, result.length() -1);
visited[startIndex] = false;
}
}
1.寫一個方法，用一個for循環打印九九乘法表
Java code
/**
* 打印九九乘法口訣表
*/
public
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();
}
}
}
2.給定一個java.util.Date對象，如何轉化爲」2007-3-22 20:23:22」格式的字符串
Java code
/**
* 將某個日期以固定格式轉化成字符串
* @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;
}
3.寫一個方法，可以判斷任意一個整數是否素數
/**
* 判斷任意一個整數是否素數
* @param num
* @return boolean
*/
public boolean isPrimeNumber(int num)
{
for (int i = 2; i <= Math.sqrt(num); i++) {
if(num%i==0)
{
return false;
}
}
return true;
}
4.寫一個方法，輸入任意一個整數，返回它的階乘
Java code
/**
*得到任意一個整數的階乘
*@param n
*@returnn!
*/
public int factorial(int num)
{
//遞歸
if(num == 1)
{
return 1;
}
return num*factorial(num-1);
}
5.寫一個方法，用二分查找法判斷任意整數在任意整數數組裏面是否存在，若存在就返回它在數組中的索引位置，不存在返回-1
Java code
/**
*二分查找特定整數在整型數組中的位置(遞歸)
*@param dataset
*@param data
*@param beginIndex
*@param endIndex
*@return index
*/
public 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 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; }