笔试常用算法

1.滑动数组

思路：先记录下第一个要求长度里满足的条件值，再设置左右指针分别向前推进数组，并计算新数组的条件值，遍历结束记录下最大值返回。

public int maxVowels(String s, int k) {
        char [] ch = s.toCharArray();
        int left=-1,right=k-1,max = 0,sum=0;
        for(int i=0;i<ch.length&&i<k;i++){
            if(check(ch[i]))max++;
        }
        sum=max;
        while(right<ch.length){
            left++;
            right++;
            if(right<ch.length&&check(ch[right]))sum++;
            if(check(ch[left]))sum--;
            max = Math.max(max,sum);
        }

        return max;
    }

 

KMP算法

import java.util.*;
public class KMP {
    public static void main(String[] args){
        String str1="ababaababca";
        String str2="ababca";
        int[] next=Getnext(str2);
        System.out.println(Arrays.toString(next));
        int x=KMP(str1,str2,next);
        System.out.println(x);
    }
    public static int[] Getnext(String str2){
        int len=str2.length();
        int [] next=new int[len];
        next[0]=-1;
        int i=0,j=-1;
        while(i<len-1){
            if(j==-1||str2.charAt(i)==str2.charAt(j)){
                next[++i]=++j;
            }
            else
                j=next[j];
        }
        return next;
    }
    public static int KMP(String str1,String str2,int[] next){
        int x=0,y=0;
        int len=str2.length();
        while(x<str1.length()&&y<len){
            if(y==-1||str1.charAt(x)==str2.charAt(y)){
                x++;y++;
            }
            else
                y=next[y];
            System.out.println(x +" "+y);
        }
        return y==len?x-y:-1;
    }
}

快速排序（从大到小）

public class KSPX {

	public static void main(String[] args) {
		int sum[]={2,6,8,9,15,4,7,9,5};
		SSR(sum,0,sum.length-1);
		for(int i=0;i<sum.length;i++){
			System.out.print(sum[i]+" ");
		}

	}
      public static void SSR(int[] sum,int strart,int end){
    	if(strart<end){
    		int p=core(sum,strart,end);
    		SSR(sum,strart,p-1);
    		SSR(sum,p+1,end);
    	}      
    }
      public static int core(int[] sum, int strart,int end){
    	  int x=sum[end];
    	  int i=strart;//记录下标
    	  for(int j=strart;j<end;j++){
    		  if(sum[j]>x){
    			  wap(sum,i,j);
    			  i++;
    		  }
    	  }
    	  wap(sum,i,end);
    	  return i;
      }
      
      public static void wap(int[] sum,int i,int j){
    	  int a=sum[i];
    	  sum[i]=sum[j];
    	  sum[j]=a;
    		
      }
 
}

二分查找

public static int erSearch(int[] A,int k){
		int x=0,y=A.length-1;
		int middle=0;
		if(k < A[x]||k > A[y]||x > y)
			return -1;	
		while(x<=y){
			middle=(x+y)/2;
			if(A[middle]>k){
				y=middle-1;
			}
			else if(A[middle]<k){
				x=middle+1;
			}
			else
				return middle;
		}
		return -1;
	}

并归排序

堆排序

import java.lang.reflect.Array;
import java.util.*;
public class HeapSort {
    public static void main(String[] args) {
        int[] array = new int[] { 2, 1, 4, 3, 6, 5, 8, 7 };
        sort(array);
        System.out.println(Arrays.toString(array));
    }

    public static void sort(int[] array) {
        for (int i = array.length / 2 - 1; i >= 0; i--) {
            adjustHeap(array, i, array.length);
        }
        for (int j = array.length - 1; j > 0; j--) {
            // 元素交换
            swap(array, 0, j);
            adjustHeap(array, 0, j);
        }
    }

    public static void adjustHeap(int[] array, int i, int length) {
        int temp = array[i];
        for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {
            if (k + 1 < length && array[k] < array[k + 1]) {
                k++;
            }
            // 如果发现子节点更大，则进行值的交换
            if (array[k] > temp) {
                swap(array, i, k);
                // 所以，循环对子节点所在的树继续进行判断
                i = k;
                // 如果不用交换，那么，就直接终止循环了
            } else {
                break;
            }
        }
    }

    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

Manacher算法

二叉树的层次遍历（队列实现）

import java.util.Queue;
import java.util.LinkedList;
public class Solution {
    public int TreeDepth(TreeNode root) {
        if(root==null){
            return 0;
        }
        Queue<TreeNode> list=new LinkedList<>();
        list.add(root);
        int len=0,sum=0,count=1;//sum为当前计算的父节点数，count为之前存储的父节点数
        while(list.size()!=0){
        TreeNode top=list.poll();
        sum++;  
        if(top.left!=null){
            list.offer(top.left);
        }
        if(top.right!=null){
            list.offer(top.right);
        }
        if(sum==count){  //当扫描完一层时，深度加1
            count=list.size();
            sum=0;
            len++;
        }
        }
        return len;
    }
}