数组冒泡排序
-
相邻两个数两两相比，n[i]跟n[j+1]比，如果n[i]>n[j+1]，则将连个数进行交换，
-
j++, 重复以上步骤，第一趟结束后，最大数就会被确定在最后一位，这就是冒泡排序又称大（小）数沉底，
-
i++,重复以上步骤，直到i=n-1结束，排序完成。
-
时间复杂度都是O（n2）
int num[]={34,212,12,25,57,48};
for(int i=0;i<num.length-1;i++){
for (int j=0;j<num.length-i-1;j++){
if(num[j]>num[j+1]){
int flag =num[j];
num[j]=num[j+1];
num[j+1]=flag;
}
}
}
for(int a : num){
System.out.println(a);
}
选择排序
-
第一个跟后面的所有数相比，如果小于（或小于）第一个数的时候，暂存较小数的下标，第一趟结束后，将第一个数，与暂存的那个最小数进行交换，第一个数就是最小（或最大的数）
-
下标移到第二位，第二个数跟后面的所有数相比，一趟下来，确定第二小（或第二大）的数
重复以上步骤
直到指针移到倒数第二位，确定倒数第二小（或倒数第二大）的数，那么最后一位也就确定了，排序完成。 -
时间复杂度都是O（n2）
代码：
public class Sort {
public static void main(String[] args) {
int[] array =new int[]{2,5,7,3,1,8} ;
int[] result =selectionSort(array);
for(int num:result){
System.out.println(num);
}
}
public static int[] selectionSort(int[] array){
int minIndex ,temp;//minIndex最小值索引
for(int i=0;i<array.length-1;i++){
minIndex=i;
for(int j=i+1;j<array.length;j++){
if(array[j] <array[minIndex]){
minIndex=j;
}
}
temp =array[i];
array[i] =array[minIndex];
array[minIndex]=temp;
}
return array;
}
}
一个数组中，只有一个数字出现一次，其他数字都出现两次，请编程找出这个数字。
int array[] ={1,1,2,2,3,3,4,5,5};
System.out.println(getionenum(array));
自己写的方法（全部数字的总和-两次出现数字的总和*2）
public static int getionenum(int[] array){
int total=0;
int total2 =0;
for(int i=0;i<array.length;i++){
total=total+array[i];
}
for(int j=0;j<array.length;j++){
//j后面的数字和j比
for(int k=j+1;k<array.length;k++){
if(array[k]==array[j]){
total2=total2+array[k];
System.out.println(total2);
}
}
}
return total-total2*2;
}
高玩解法:利于异或运算
public static int getionenum(int[] array){
int resualt=0;
for(int i=0;i<array.length;i++)
{
//resualt^=array[i];
resualt= resualt^array[i];
}
return resualt;
解释：resualt =0^array[1] ^array[2] … ^array[i]
- 同一个数字异或两遍相当于没有异或
- 异或运算可交换
- 0 ^1=1 ; 1 ^1 =0
最终结果:resualt =0 ^4= 4
JavaScript实现倒计时功能
<div id="div">
</div>
<script>
function resetTime(time) {
var timer=null;
var t=time;
var m=0;
var s=0;
m=Math.floor(t/60%60);
m<10&&(m='0'+m);
s=Math.floor(t%60);
function countDown(){
s--;
s<10&&(s='0'+s);
if(s.length>=3){s=59;
m=m-1;
}
if(m.length>=3){
m='00';
s='00';
clearInterval(timer);
}
var div =document.getElementById("div");
div.innerHTML=m+"分钟"+s+"秒";
}
timer=setInterval(countDown,1000);
}
resetTime(2353);
</script>
//String数组转int数组
public static int[] StringToInt(String[] arrs){
int[] ints = new int[arrs.length];
for(int i=0;i<arrs.length;i++){
ints[i] = Integer.parseInt(arrs[i]);
}
return ints;
}
//String 字符串拆分 1:11,2:11,
String goods=request.getParameter("goods");
String [ ] line=goods.split(",");
for(String str:line) {
System.out.println(str);
String [ ] line2=str.split(":");
for (String s:line2){
System.out.println(s);
}
}
尽量均分
public static int[] matchExpert2(int total,int count){
int anArray[] = new int[count];
if(total % count == 0){
int recordExpert = total / count;
for(int expertNum:anArray){
expertNum = recordExpert;
System.out.println(expertNum);
}
}else {
int recordCount1 = (total / count)+1;
int n=0;//n表示组中记录数为recordCount1的最大专家数.
int m=recordCount1*n;
while (((total-m) % (count -n )) !=0){
n++;
m=recordCount1*n;
anArray[n-1] = recordCount1;
System.out.println(recordCount1);
}
int recordCount2 = (total - m) /(count-n);
for (int i=n;i <count;i++){
anArray[i] = recordCount2;
System.out.println(recordCount2);
}
//将前n个组的记录数设为recordCount1.
//将n+1个至后面所有组的记录数设为recordCount2.
}
System.out.println(Arrays.toString(anArray));
return anArray;
}
尽量均分（不能均分时，整除平均值上浮动1或2）
public int[] matchExpert(int total,int count){
int anArray[] = new int[count];
if(total % count == 0){//均分
int recordExpert = total / count;
for(int i=0;i<anArray.length;i++){
anArray[i] = recordExpert;
}
}else {
Random ra = new Random();
int temp =ra.nextInt(2)+1;//随机1或2
int recordCount1 = (total / count)+temp;//专家数
int n=0;//n表示组中记录数为recordCount1的最大专家数.
int m=0;
while (((total-m) % (count -n )) !=0){
if((total-m) % (count -n ) == 1){//如果只剩下一个，就分配一个
recordCount1 = (total / count)+1;//专家数
}else {
temp = ra.nextInt(2) + 1;//随机1或2
recordCount1 = (total / count) + temp;//专家数
}
n++;
m=m+recordCount1;
anArray[n-1] = recordCount1;
}
int recordCount2 = (total - m) /(count-n);
for (int i=n;i <count;i++){
anArray[i] = recordCount2;
}
//将前n个组的记录数设为recordCount1.
//将n+1个至后面所有组的记录数设为recordCount2.
}
randomArr(anArray);
return anArray;
}
数组打散（随机）
public static void randomArr(int[] num) {
Random random = new Random();
int index;
for (int i = (num.length - 1); i >= 0; i--) {
index = random.nextInt(num.length);
int temp = num[i];
num[i] = num[index];
num[index] = temp;
}
System.out.println(Arrays.toString(num));
}
统计重复的字母 如xxyyyyyzzz变成2x4y3z （面试题）
public class StringTo {
public static void main(String[] args) {
String str = "xxyyyyvzzzddduuuuuui";//输入字符
String result = stringToSomeString(str);
System.out.println(result);
}
public static String stringToSomeString(String str){
String[] strArr = str.split("");
String result = "";//结果
String now = "";//当前字符
String temp = "";//之前字符
int sum = 1;//字符统计数
for(int i= 0;i<strArr.length;i++){
now = strArr[i];
if(i==0){
temp = strArr[i];
continue;
}
//当字符为最后一个字符是，字符必须输出
if(i==strArr.length-1){
//当前字符和之前字符相等
if(now.equals(temp)){
sum +=1;
}
if(sum == 1){
//之前字符出现1次
result += temp;
}else{
//之前字符出现sum次
result += String.valueOf(sum)+temp;
sum = 1;
}
//不相等 输出最后一个字符
if(now.equals(temp)){
}else{
result += now;
}
}else{//当字符不是最后一个字符，字符如果重复不输出，统计加一
//当前字符和之前字符相等
if(now.equals(temp)){
sum +=1;
}else{
if(sum == 1){
//之前字符出现1次
result += temp;
}else{
//之前字符出现sum次
result += String.valueOf(sum)+temp;
sum = 1;
}
temp = now;
}
}
}
return result;
}
}
关于代码的执行顺序
以下代码输出结果为多少
public class testReal {
public static void main(String[] args) {
A ab =new B();
B abc=new B();
}
}
class A{
static {
System.out.println("1");
}
public A(){
System.out.println("2");
}
}
class B extends A{
static {
System.out.println("A");
}
public B(){
System.out.println("B");
}
}
正确结果：
1
A
2
B
2
B
改成下面也一样
A ab =new B();
A abc=new B();
B ab =new B();
B abc=new B();
知识点：
1.1、一个类中的初始化顺序
类内容（静态变量、静态初始化块） => 实例内容（变量、初始化块、构造器）
1.2、两个具有继承关系类的初始化顺序
父类的（静态变量、静态初始化块）=> 子类的（静态变量、静态初始化块）=> 父类的（变量、初始化块、构造器）=> 子类的（变量、初始化块、构造器）
1.3 静态变量和静态初始化快，只执行一次