一,冒泡排序:
package com.sort;
import java.util.Random;
public class No1Maopao {
public static void main(String[] args) {
Random rd = new Random();
//生成随即数组
int [] src = new int[10];
for(int i=0;i<10;i++){
src[i]=rd.nextInt(100);
}
//排序前打印数组所有元素
for(int i:src)
System.out.println(i);
System.out.println("---------------可爱的分割线-------------------");
src = sort(src);
//排序后打印数组所有元素
for(int i:src)
System.out.println(i);
}
public static int[] sort(int [] src){
for (int i = 0; i < src.length; i++) {
for(int j=i;j<src.length;j++){
if(src[j]<src[i]){
int temp = src[j];
src[j]=src[i];
src[i]=temp;
}
}
}
return src;
}
}
二、选择排序:
package com.sort;
import java.util.Random;
public class No2XuanZhe {
public static void main(String[] args) {
Random rd = new Random();
int[] src = new int[10];
for (int i = 0; i < 10; i++) {
src[i] = rd.nextInt(100);
}
for (int i : src)
System.out.println(i);
System.out.println("---------------可爱的分割线-------------------");
src = sort(src);
for (int i : src)
System.out.println(i);
}
public static int[] sort(int[] src) {
int min;
for (int i = 0; i < src.length; i++) {
min = src[i];
for (int j = i + 1; j < src.length; j++) {
if (src[j] < min) {
min = src[j];
int temp = src[i];
src[i] = src[j];
src[j] = temp;
}
}
}
return src;
}
}
三、插入排序:
package com.sort;
import java.util.Random;
public class No3ChaRu {
public static void main(String[] args) {
Random rd = new Random();
int[] src = new int[10];
for (int i = 0; i < 10; i++) {
src[i] = rd.nextInt(100);
}
for (int i : src)
System.out.println(i);
System.out.println("---------------可爱的分割线-------------------");
src = sort(src);
for (int i : src)
System.out.println(i);
}
public static int[] sort(int[] src) {
int in, out;
for (in = 1; in < src.length; in++) {
int temp = src[in];
out = in;
while (out > 0 && src[out - 1] >= temp) {
src[out] = src[out - 1];
--out;
}
src[out] = temp;
}
return src;
}
}
四、希尔排序:
package com.sort;
import java.util.Random;
public class No4Xier {
public static void main(String[] args) {
Random rd = new Random();
int[] src = new int[10];
for (int i = 0; i < 10; i++) {
src[i] = rd.nextInt(100);
}
for (int i : src)
System.out.println(i);
System.out.println("---------------可爱的分割线-------------------");
src = sort(src);
for (int i : src)
System.out.println(i);
}
public static int[] sort(int[] src) {
int len = src.length;
int temp, i, j;
int h = 1;
while (h <= len / 3)
h = h * 3 + 1;
while (h > 0) {
for (i = h; i < len; i++) {
temp = src[i];
j = i;
while (j > h - 1 && src[j - h] >= temp) {
src[j] = src[j - h];
j -= h;
}
src[j] = temp;
}
h = (h - 1) / 3;
}
return src;
}
}
五、快速排序:
public class No5Kuaisu {
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;
}
public static void main(String[] args) {
Random rd = new Random();
int[] src = new int[10];
for (int i = 0; i < 10; i++) {
src[i] = rd.nextInt(100);
}
for (int i : src)
System.out.println(i);
System.out.println("---------------可爱的分割线-------------------");
quickSort(src);
for (int i : src)
System.out.println(i);
System.out.println("---------------可爱的分割线-------------------");
}
}
1.写一个方法,用一个for循环打印九九乘法表
/** *//**
* 打印九九乘法口诀表
*/
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”格式的字符串
/** *//**
* 将某个日期以固定格式转化成字符串
* @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.写一个方法,输入任意一个整数,返回它的阶乘
/** *//**
*获得任意一个整数的阶乘
*@param n
*@returnn!
*/
public int factorial(int num)
{
//递归
if(num == 1)
{
return 1;
}
return num*factorial(num-1);
}
5.写一个方法,用二分查找法判断任意整数在任意整数数组里面是否存在,若存在就返回它在数组中的索引位置,不存在返回-1
/** *//**
*二分查找特定整数在整型数组中的位置(递归)
*@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;
}