数组冒泡排序
-
相邻两个数两两相比,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 静态变量和静态初始化快,只执行一次