速来围观！leetcode java实现汇总

---

前言

目前是算法横行的时代，逻辑很重要，特出此文章做一个总结会持续更新

---

一、排序

swap异或算法用的前提是交换的数组的元素a和b分别在不同的内存里。如果在数组中想进行交换，一定要保证i和j不能相等。

1.1 选择排序

将第循环里的第一个元素和后面的比，谁小把谁放到前面，时间复杂度为n的平方

class SelectionSort(int[] arr){
    public void selectionSort(int[] arr){
      //排除杂条件
      if(arr == null || arr.length < 2){
          return;
      }
      for (int i = 0; i < arr.length; i++){
        //外层循环的每一个i先设置为此循环的最小值的索引，给到内层循环进行比较
         minIndex = i;
         for (int j = i+1; j<arr.length;j++){
            minIndex = arr[j] < arr[minIndex] ? j : minIndex;
         }
         //每次一个大循环找到一个该轮最小值放到第一个
          swap(arr,i,minIndex)
      }
      
     
    }

    public void swap(int[] arr;int i;int minIndex){
        int tmp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = tmp;
    }
}

1.2 冒泡排序

选择排序是将最小的放到第一位，而冒泡排序是将最大的放到最后一位，并且每次都是相邻两个在比。

class Solution {
    public int[] sortArray(int[] nums) {
bubbleSort(nums);
return nums;
    }
    public void bubbleSort(int[] arr){
     if(arr == null || arr.length < 2){
          return;
      }
     for(int i = 0;i<arr.length;i++){
         for(int j=0;j<arr.length-1-i;j++){
             if(arr[j]>arr[j+1]){
                 swap(arr,j,j+1);
             }
         }}}
     

    public void swap(int[] arr,int i,int j){
    //异或还可以理解为无进位相加，下面方法的使用前提是arr[i]指向的内存和arr[j]指向的内存是两块不同的内存，因为同样的内存异或会成为0
       int tmp = arr[i] ;
       arr[i] = arr[j];
       arr[j] = tmp;
    }


}

1.3 插入排序

按照算法可能情况的最差估计时间复杂度为n的平方，每次循环都保证0-n的地方是有序排序的，而且每次都是先跟前一位比，不行了才会进行互换，否则不互换，这样他最好的实现状况是时间复杂度为n。

class InsertionSort(){
   public insertSort(int[] arr){
     //排除杂条件
      if(arr == null || arr.length < 2){
          return;
      }
      //i从1开始是因为0-0上已经实现了排序
      for (int i = 1; i < arr.length; i++){//0到i做到有序,此时已经做到了0~i-1上的数有序，所以现在比较i-1（j）和第i位置的数的大小，换到不比左边位置的数小了就停止
          for(int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--){
               swap(arr, j, j + 1);
         }
      }
   }
   public void swap(int[] arr,int i,int j){
    //异或还可以理解为无进位相加，下面方法的使用前提是arr[i]指向的内存和arr[j]指向的内存是两块不同的内存，因为同样的内存异或会成为0
       arr[i] = arr[i] ^ arr[j];
       arr[j] = arr[i] ^ arr[j];
       arr[i] = arr[i] ^ arr[j];
    }
}

1.4 归并排序

左边排好序右边也排好序,复杂度为N*logN

public class MergeSort{
   public static void process(int[] arr, int L,int R){
      if(L==R){
      return;
      }
      int mid = L+((R-L)>>1);
      //先两边有序，后归并merge
      process(arr,L,mid);
      process(arr,mid,R);
      merge(arr,L,mid,R);
   }
   public static void merge(int[] arr,int L,int M,int R){
   //新设置一个数组放比较值
   int[] help = new int[R-L+1];
   int i = 0;
   int p1 = L;
   int p2 = M + 1;
   // 哪个小放哪个，并移动相应的指针
   while (p1 <= M && p2 <= R){
     help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++]
     }
   //下面两个循环只会走一个
   while (p1<=M){
     help[i++] = arr[p1++];
    }
   while (p2<=R){
     help[i++] = arr[p2++];
    }
   for(i = 0,i < help.length;i++){
    //拷贝回原来数组
     arr[L+i] = help[i]
     }
   
   }
}

1.5 快速排序

class Solution {
     public void swap(int[] nums,int L,int R){
        int tmp = nums[L];
        nums[L] = nums[R];
        nums[R] = tmp;
    }
    public int[] sortArray(int[] nums) {
      int L = 0,R = nums.length-1;
      quickSort(nums,L,R);
      return nums;
    }
    public void quickSort(int[] nums,int L,int R){
 if(L<R){//递归终止条件
          swap(nums,L+(int)(Math.random()*(R-L+1)),R);//找随机一个数字和最后一个元素互换，记住加一
          int[] middleIndex = partiton(nums,L,R);//进行分区，返回的是等于区的左索引坐标和右索引index
          quickSort(nums,L,middleIndex[0]-1);//减一是因为小于区的最右边界处是等于区最左边界减一
          quickSort(nums,middleIndex[1]+1,R);//加一是因为大于区最左边界是等于区最右边界加一
        }
    }
    public int[] partiton(int[] nums,int L,int R){//L相当于此时的第三个指针
         int less = L-1;//减一是因为小于区的起始索引还没有比较，所以先将小于区的指针指向第一个索引的前面一个，不能改成L+1，这样就默认第一个数字确实比被比较的数字小了，万一没有一个就会出错
        int more = R;//这里R不减一是因为最后一个是被比较数字，所以开始的大于区的指针是在他前面的
        while(L<more){
        if(nums[L]<nums[R]){//L代表现在这一段的比较数字的指针
            swap(nums,++less,L++);
        }else if(nums[L]>nums[R]){
swap(nums,--more,L);//指针不前移，因为此时大于区的左边界换过来的数据还没有进行比较
        }else{
            L++;
        }
    }   
    swap(nums,more,R);
    return new int[]{less+1,more};//返回的more没有加1是因为最后进行了交换，也就是上一行代码，此时more指向的是等于区的最后一个元素，把最后一个元素交换过来的就是被比较数字
    }  
}

二、查找

2.1 二分查找（有序数组找某个数是否存在）

时间复杂度为log2N

三、寻找最大数字

寻找某一个数组里的某一段区间的最大值

public class GetMax{
   public static int process(int[] arr, int L,int R){
     if(L==R){
      return arr[L]; 
      }
    int mid = ((R-L)>>1);//寻找到中点
    //递归调用
    int leftMax = process(arr,L,mid);
    int rightMax = process(arr,mid+1,R);
    return Math.max(leftMax,rightMax);
   }
}

四、两数之和

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; i++) {
            if(map.containsKey(target - nums[i])) {
                return new int[] {map.get(target-nums[i]),i};
            }
            map.put(nums[i], i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}