每日下班试题

7.11

1.实现一个Singleton模式

java中单例模式是一种常见的设计模式，它具有以下特点：单例类只能有一个实例；单例类必须自己创建自己的唯一实例；单例类必须给所有其他对象提供这一实例。

饿汉式单例：典型的空间换时间，当类装载的时候就会创建类的实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断，节省了运行时间。

//饿汉式单例，在类初始化前已经实例化public class Singleton {      private Singleton() {}      private static final Singleton single = new Singleton();      //静态工厂方法       public static Singleton getInstance() {          return single;      }  }  

懒汉式单例：是典型的时间换空间,就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间

//懒汉式单例类.在第一次调用的时候实例化自己   public class Singleton {      private Singleton() {}      private static Singleton single=null;      //静态工厂方法       public static Singleton getInstance() {           if (single == null) {                 single = new Singleton();           }            return single;      }  }  

采用静态内部类的方法实现懒汉式的线程安全以及加载延迟

public class Singleton {        private static class LazyHolder {           private static final Singleton INSTANCE = new Singleton();        }        private Singleton (){}        public static final Singleton getInstance() {           return LazyHolder.INSTANCE;        }    }    

2.二维数组中查找：在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。完成一个函数，输入这样的一个二维数组，判断数组中是否有该整数

//从右上角开始逐行遍历，可改为二分查找遍历降低时间复杂度public class SearchArray{int a[][1000],m,n,key; //二维数组，行，列，查找值public string search(a[][1000],m,n,key){int i=0;int j=n-1;while(1<m&&j>=0){if(a[i][j]==key)return "YES";else if(a[i][j]<key)i++;elsej--}}}//思路是搜寻算法，定位在左下角，比较目标值，比目标值小就向右移；比目标值大就向上移class Solution {public:    bool Find(vector<vector<int> > array,int target) {       int m,n,x,y;        m = array.size();//行数        n = array[0].size();//列数        x=m-1;y=0;//坐标定在左下角        while(x>=0 && y<=n-1){          if(target<array[x][y]){                       x--;//遇小上移                 }          else if(target>array[x][y]){                       y++;//遇大右移                 }          else {               return true;             }      }       return false;    }};

3.字符串：例如字符串的替换空格，输入“We are happy”,则输出“We%20are%20happy”

public class ReplaceBlank {      private static String testString = "hellow new world!";        // 计算字符串中包含的空格个数      public static int getBlankNum(String testString) {          int count = 0;          for (int i = 0; i < testString.length(); i++) {              String tempString = String.valueOf(testString.charAt(i));              if (tempString.equals(" ")) {                  count++;              }          }          return count;      }        // 打印char[]数组      public static void printArray(char[] testArray) {          for (char i : testArray) {              System.out.print(i);          }          System.out.println();      }        // 将字符串空格转换为20%      public static void replaceAllBlank(String testString) {            if (testString == null || testString.length() <= 0) {              return;          }          // 字符数组初始长度          int length = testString.length();          // 字符数组增加长度后          int newLength = newLength = getBlankNum(testString) * 2                  + testString.length();          char[] tempArray = new char[newLength];          System.arraycopy(testString.toCharArray(), 0, tempArray, 0, testString                  .toCharArray().length);          int indexofOriginal = length - 1;          int indexofNew = newLength - 1;          System.out.println("未替换空格时的字符串：");          printArray(tempArray);          while (indexofOriginal >= 0 && indexofOriginal != indexofNew) {              if (tempArray[indexofOriginal] == ' ') {                  tempArray[indexofNew--] = '%';                  tempArray[indexofNew--] = '2';                  tempArray[indexofNew--] = '0';              } else {                  tempArray[indexofNew--] = tempArray[indexofOriginal];              }              indexofOriginal--;          }          System.out.println("替换空格后的字符串：");          printArray(tempArray);        }        public static void main(String[] args) {          replaceAllBlank(testString);      }  }  

4.查找排序（二分查找，并归排序，快速排序）

//非递归二分查找算法
public static int search(Integer[]srcArry,int key){
//搜索范围起始位置
int start =0; 
//搜索范围结束位置
int end = srcArry.length-1; 
while(start<=end)
int middle=start+(start+end)/2;
//与中间数字进行判断，决定下一步搜索范围
if(key==srcArry[middle])  
return middle;
else if(key<srcArry[middle]) 
end=middle-1;
else
start=middle+1;
return 0;
}


//递归二分查找
public static int search(Int Arry,int start,int end,int key){
if(start<=end){
int middle = (start+end)/2;
if(key==Arry[middle])
return middle;
else if(key<Arry[middle])
return search(Array,start,middle-1);
else if(key>Array[middle])
return search(Array,middle+1,end);
}
else
return 0;
}


//并归排序,将两个有序表合并成一个新的有序表
public class MergeSort{
//返回并归排序方法
public static int[] sort(int[] nums,int start,int end){
int mid = (start + end)/2;
if(start<end){
sort(nums,start,mid);
sort(nums,mid+1,end);
merge(start,mid,end);
}
return nums;
}
public static void merge(int[] nums,int start,int mid,int end){
int[]temp = new int [end-start+1];
int i=start;
int j=mid+1;
int k=0;
//两个有序表进行对比，将较小的数移入新的数组中
while(i<=mid&&j<=end){
if(nums[i]<nums[j]){
temp[k++]=nums[i++];
}else{
temp[k++]=nums[j++]
}
}
//当有一个表移完之后，将另一表剩余的数全部移入新数组中
while(i<=mid){
temp[k++]=nums[i++];
}
while(j<=mid){
temp[k++]=nums[j++];
}
//对原有nums数组进行覆盖
for(int p=0;p<temp.length;p++){
nums[p+start]=nums[p];
}
}
}


//快速排序
//快速排序是对冒泡排序的一种改进。它的基本思想是：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
 static void quicksort(int n[], int left, int right) {
        int dp;
        if (left < right) {
            dp = partition(n, left, right);
            quicksort(n, left, dp - 1);
            quicksort(n, dp + 1, right);
        }
    }
 
    static int partition(int n[], int left, int right) {
        int pivot = n[left];
        while (left < right) {
            while (left < right && n[right] >= pivot)
                right--;
            if (left < right)
                n[left++] = n[right];
            while (left < right && n[left] <= pivot)
                left++;
            if (left < right)
                n[right--] = n[left];
        }
        n[left] = pivot;
        return left;
    }