大厂代码面手撕基础题

不要纠结，干就完事了，熟练度很重要！！！多练习，多总结！！！

快速排序

代码实现

class Solution {
   
    public int[] sortArray(int[] nums) {
   
        sort(nums, 0, nums.length-1);
        return nums;
    }

    public void sort(int[] nums, int lo, int hi){
   
        if(lo > hi){
   
            return ;
        }

        int j = partition(nums, lo, hi);
        sort(nums, lo, j-1);
        sort(nums, j+1, hi);
    }

    public int partition(int[] nums, int lo, int hi){
   
        int pivot = nums[lo];
        int i = lo+1, j = hi;
        while(i <= j){
   
            while(i < hi && nums[i] < pivot){
   
                i++;
            }

            while(j > lo && nums[j] > pivot){
   
                j--;
            }
            if(i >= j){
   
                break;
            }
            swap(nums, i, j);
        }
        swap(nums, lo, j);
        return j;
    }

    public void swap(int[] nums, int i, int j){
   
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

归并排序

代码实现

class Solution {
   
    int[] temp;
    public int[] sortArray(int[] nums) {
   
        temp = new int[nums.length];
        sort(nums, 0, nums.length-1);
        return nums;
    }

    public void sort(int[] nums, int low, int high){
   
        if(low >= high){
   
            return;
        }
        int mid = low + (high-low)/2;
        sort(nums, low, mid);
        sort(nums, mid+1, high);
        merge(nums, low, mid, high);

    }

    public void merge(int[] nums, int low, int mid, int high){
   
        for(int i = low; i <= high ;i++){
   
            temp[i] = nums[i];
        }

        int i = low, j = mid+1;
        for(int k = low;k <= high;k++){
   
            if(i == mid + 1){
   
                nums[k] = temp[j++];
            }else if(j == high+1){
   
                nums[k] = temp[i++];
            }else if(temp[i] > temp[j]){
   
                nums[k] = temp[j++];
            }else {
   
                nums[k] = temp[i++];
            }
        }
    }
}

单例模式

代码实现

懒汉式：
双重校验，线程安全且在多线程情况下能保持高性能。

public class Singleton {
     
    private volatile static Singleton singleton;  
    private Singleton (){
   }  
    public static Singleton getSingleton() {
     
	    if (singleton == null) {
     
	        synchronized (Singleton.class) {
     
	            if (singleton == null) {
     
	                singleton = new Singleton();  
	            }  
	        }  
	    }  
	    return singleton;  
    }  
}

饿汉式：
线程安全，在程序启动时直接运行加载，但是可能造成资源浪费。

public class Singleton {
     
    private static Singleton instance = new Singleton();  
    private Singleton (){
   }  
    public static Singleton getInstance() {
     
   		return instance;  
    }  
}

LRU Cache

代码实现

public class LRUCache {
   
   class LinkedNode {
   
     int key;
     int value;
     LinkedNode prev;
     LinkedNode next;
   }
 
  private void addNode(LinkedNode node) {
   
    node.prev = head;
    node.next = head.next;
    head.next.prev = node;
    head.next = node;
  }

  private void removeNode(LinkedNode node){
   
    LinkedNode prev = node.prev;
    LinkedNode next = node.next;
    prev.next = next;
    next.prev = prev;
  }

  private void moveToHead(LinkedNode node){
   
    removeNode(node);
    addNode(node);
  }

  private LinkedNode popTail() {
   
    LinkedNode res = tail.prev;
    removeNode(res);
    return res;
  }

  private Hashtable<Integer, LinkedNode> cache = new Hashtable<Integer,LinkedNode>();
  private int size;
  private int capacity;
  private LinkedNode head, tail;

  public LRUCache(int capacity) {
   
    this.size = 0;
    this