手撕代码总结

最新推荐文章于 2024-05-19 18:55:37 发布

Flashdog.

最新推荐文章于 2024-05-19 18:55:37 发布

阅读量889

点赞数

分类专栏： JAVA 文章标签：链表数据结构 java

本文链接：https://blog.csdn.net/flashdog8/article/details/120017052

版权

JAVA 专栏收录该内容

44 篇文章 1 订阅

订阅专栏

排序算法复杂度

在这里插入图片描述

数组中出现次数超过一半的数字

摩尔投票法：每次从序列里选择两个不相同的数字删除掉（或称为“抵消”），最后剩下一个数字或几个相同的数字，就是出现次数大于总数一半的那个。
题目链接

public int majorityElement(int[] nums) {
        int res = 0;
        int vote = 0;
        for (int i : nums) {
            if (vote == 0) {
                res = i;
            }
            vote += (res == i) ? +1 : -1;
        }
        return res;
    }

最小覆盖子串

题解

public String minWindow(String s, String t) {
        Map<Character,Integer> tMap=new HashMap<>();
        Map<Character,Integer> sMap=new HashMap<>();
        for(int i=0;i<t.length();i++){
            tMap.put(t.charAt(i),tMap.getOrDefault(t.charAt(i),0)+1);
        }
        int i,j,cnt=0,len=s.length()+1;
        String res="";
        for(i=0,j=0;i<s.length();i++){
            sMap.put(s.charAt(i),sMap.getOrDefault(s.charAt(i),0)+1);
            if(tMap.containsKey(s.charAt(i))&&sMap.get(s.charAt(i))<=tMap.get(s.charAt(i)))cnt++;
            while(j<i&&(!tMap.containsKey(s.charAt(j))||sMap.get(s.charAt(j))>tMap.get(s.charAt(j)))){
                sMap.put(s.charAt(j),sMap.get(s.charAt(j))-1);
                j++;
            }
            if(cnt==t.length()&&i-j+1<len){
                len=i-j+1;
                res=s.substring(j,i+1);
            }
        }
        return res;
    }

三数和

 public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result=new ArrayList<>();
        int len=nums.length;
        if(len<3)return result;
        Arrays.sort(nums);
        int left,right;
        for(int i=0;i<len;i++){
            if(nums[i]>0)break;
            if(i>0&&nums[i]==nums[i-1])continue;
            left=i+1;
            right=len-1;
            while(left<right){
                int sum=nums[i]+nums[left]+nums[right];
                if(sum==0){
                    result.add(Arrays.asList(nums[i],nums[left],nums[right]));
                    while(left<right&&nums[left]==nums[left+1])left++;
                    while(left<right&&nums[right]==nums[right-1])right--;
                    left++;
                    right--;
                }else if(sum<0)
                    left++;
                else if(sum>0)
                    right--;
            }
        }
        return result;
    }

接雨水

    public int trap(int[] height) {
        int res=0;
        if(height.length==0)return res;
        int left=0,right=0;
        for(int i=1;i<height.length-1;i++){
            left=height[i];
            right=height[i];
            for(int j=0;j<i;j++)
                left=Math.max(left,height[j]);
            for(int j=i;j<height.length;j++)
                right=Math.max(right,height[j]);
            res+=Math.min(left,right)-height[i];
        }
        return res;
    }

复杂度O（n*n)
优化后O(n)

class Solution {
    public int trap(int[] height) {
        int n = height.length;
        if (n == 0) {
            return 0;
        }
		//eftMax[i] 表示下标 ii 及其左边的位置中，height 的最大高度
        int[] leftMax = new int[n];
        leftMax[0] = height[0];
        for (int i = 1; i < n; ++i) {
            leftMax[i] = Math.max(leftMax[i - 1], height[i]);
        }
		//rightMax[i] 表示下标 ii 及其右边的位置中，height 的最大高度
        int[] rightMax = new int[n];
        rightMax[n - 1] = height[n - 1];
        for (int i = n - 2; i >= 0; --i) {
            rightMax[i] = Math.max(rightMax[i + 1], height[i]);
        }

        int ans = 0;
        //位置i左边和右边最大高度的最小值减去height[i]就是该位置能接的雨水
        for (int i = 0; i < n; ++i) {
            ans += Math.min(leftMax[i], rightMax[i]) - height[i];
        }
        return ans;
    }
}

链表环

**
 1. 关于链表环的两个结论：
 2. 1.设置快慢指针，假如有环，他们最后一定相遇。(快指针一次两步，慢指针一次一步)
 3. 2.两个指针分别从链表头和相遇点继续出发，每次走一步，最后一定相遇在环入口。
 */
public class EntryNodeOfLoop {
    public ListNode entryNodeOfLoop(ListNode pNode) {
        ListNode low = pNode;
        ListNode fast = pNode;
        while (fast != null && fast.next != null) {
            low = low.next;
            fast = fast.next.next;
            if (low == fast)
                break;//链表存在环
        }
        if (fast == null || fast.next == null)//链表没有环
            return null;
        low = pNode;
        while (low != fast) {
            low = low.next;
            fast = fast.next;
        }
        return low;
    }
}

代理模式

代理模式使得客户端通过代理对象间接使用目标对象，
代理对象是对目标对象功能的增强。
代理类主要负责为目标对象预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等，委托类负责具体的实现

public class Daili {

    public static void main(String[] args) {
        RealMovie realMovie=new RealMovie();
        Cinema cinema=new Cinema(realMovie);
        cinema.play();
    }
}
//抽象主题
interface Movie {
    void play();
}
//真实电影类，被代理对象
class RealMovie implements Movie {
    @Override
    public void play() {
        System.out.println("播放电影<让子弹飞>");
    }
}
//代理对象，对play()进行增强
class Cinema implements Movie {
    RealMovie realMovie;

    Cinema(RealMovie realMovie) {
        this.realMovie = realMovie;
    }

    @Override
    public void play() {
        adPlay(true);
        realMovie.play();
        adPlay(false);
    }

    public void adPlay(boolean flag) {
        if (flag) {
            System.out.println("电影开始，播放开场广告");
        } else {
            System.out.println("电影结束，播放结束广告");
        }
    }
}

工厂模式

通过工厂模式，将创建产品实例的权利移交工厂，我们不再通过new来创建我们所需的对象，而是通过工厂来获取我们需要的产品。降低了产品使用者与使用者之间的耦合关系

package shejimoshi;

public class Factory {
    public static void main(String[] args) {
        //工厂模式
        carFactory bwm = new bmwFactory();
        Car car = bwm.create();
        car.run();

        carFactory benz=new benzFactory();
        Car car1 = benz.create();
        car1.run();
    }
}

//定义车的接口
interface Car {
    void run();
}

class Bmw implements Car {
    @Override
    public void run() {
        System.out.println("bmw---run");
    }
}

class Benz implements Car {
    @Override
    public void run() {
        System.out.println("Benz--run");
    }
}

//生产车的工厂抽象类
abstract class carFactory {
    public abstract Car create();
}

class bmwFactory extends carFactory {
    @Override
    public Car create() {
        return new Bmw();
    }
}
class benzFactory extends carFactory{
    @Override
    public Car create() {
        return new Benz();
    }
}

观察者模式

适用场景：当一个对象的状态改变需要通知多个对象知道，并且做出相应操作的时候（主题1——————n观察者,即一对多情形）
观察者–微信用户
被观察者–公众号，公众号发布更新，用户应该接收到
- 在被观察者类中应该实现如下几个方法：
  - 添加观察者add（）
  - 删除观察者remove（）
  - 发布通知notify（）（在此方法中，让每个观察者都能接收到通知的数据）


public class Client {
    public static void main(String[] args) {
        Gongzhonghao gz=new Gongzhonghao();

        WeixinUser user1=new WeixinUser("小明");
        WeixinUser user2=new WeixinUser("小方");
        WeixinUser user3=new WeixinUser("小红");
        gz.attach(user1);
        gz.attach(user2);
        gz.attach(user3);
        //发布消息
        gz.notify("明天暴雨");
    }
}
//抽象观察者
interface Observe {
    public void update(String message);
}
//实例观察者，微信用户
class WeixinUser implements Observe {
    private String name;

    WeixinUser(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name + "收到订阅消息：" + message);
    }
}
//抽象被观察者，即被订阅的公众号
interface Subject {
    void attach(Observe observe);

    void detach(Observe observe);

    void notify(String message);
}
//实例被观察者，公众号
class Gongzhonghao implements Subject {
    List<Observe> list = new ArrayList<>();

    @Override
    public void attach(Observe observe) {
        list.add(observe);
    }

    @Override
    public void detach(Observe observe) {
        list.remove(observe);
    }

    @Override
    public void notify(String message) {
        for (Observe observe : list) {
            observe.update(message);
        }
    }
}

生产者消费者

在这里插入图片描述

package shejimoshi;

public class Test {
    private static Integer count = 0;
    private static final Integer  FULL = 3;
    private static String Lock = "lock";

    public static void main(String[] args) {
        Test test = new Test();
        new Thread(test.new Producer()).start();
        new Thread(test.new Consumer()).start();
        new Thread(test.new Producer()).start();
        new Thread(test.new Consumer()).start();
        new Thread(test.new Producer()).start();
        new Thread(test.new Consumer()).start();

    }

    class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 3; i++) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (Lock) {
                    while (count == FULL) {
                        try {
                            Lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    count++;
                    System.out.println(Thread.currentThread().getName() + ":生产者生产，库存为" + count);
                    Lock.notifyAll();
                }
            }
        }
    }

    class Consumer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 3; i++) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (Lock) {
                    while (count == 0) {
                        try {
                            Lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    count--;
                    System.out.println(Thread.currentThread().getName() + ":消费者消费，库存为" + count);
                    Lock.notifyAll();
                }
            }
        }
    }
}

单例模式

在这里插入图片描述

package shejimoshi;

//懒汉式---用到实例再创建
public class Singleton {
    private static Singleton instance;

    private Singleton() {
    }

    private static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

//饿汉式---初始化即创建
public class Singleton1 {
    private static Singleton1 instance = new Singleton1();

    private Singleton1() {
    }

    private static Singleton1 getInstance() {
        return instance;
    }
}

//双重校验锁
public class Singleton2 {
    private static Singleton2 instance;

    private Singleton2() {
    }

    private static Singleton2 getInstance() {
        if (instance == null) {
            synchronized (Singleton2.class) {
                if (instance == null) {
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }
}

选择排序

	/*
        时间复杂度：最好=最坏=平均O(n2)
     */
  public static void main(String[] args) {
        // TODO 自动生成的方法存根
        //定义一个测试的排序数组
        int[] arr = {3, 9, -1, 10, -2};
        int min = 0;  //存储最小值的下标
        int temp = 0; //存储中间变量
        int j = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            min = i;  //假设该下标为最小值的下标
            j = i;
            for (; j < arr.length; j++) {
                if (arr[min] > arr[j]) {  //选取最小值,得到最小值得下标
                    min = j;
                }
            }
            //进行交换
            temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
            System.out.printf("第%d次排序的结果是： \n", i + 1);
            System.out.println(Arrays.toString(arr));
        }

    }

快排

题目链接

package sort;

/**
 * 最佳情况：T(n) = O(nlogn)
 * 最差情况：T(n) = O(n2)
 * 平均情况：T(n) = O(nlogn)
 */
public static void quickSort(int[] arr, int low, int high) {
        int l, r, temp, t;
        if (low > high) {
            return;
        }
        l = low;
        r = high;
        //temp就是基准位
        temp = arr[low];

        while (l < r) {
            //从右边遍历找到第一个小于temp数的位置
            while (temp <= arr[r] && l < r) {
                r--;
            }
            //从左边遍历找到第一个大于temp数的位置
            while (temp >= arr[l] && l < r) {
                l++;
            }
            //如果满足条件则交换
            if (l < r) {
                t = arr[r];
                arr[r] = arr[l];
                arr[l] = t;
            }

        }
        //最后将基准为与i和j相等位置的数字交换
        arr[low] = arr[l];
        arr[l] = temp;
        //递归调用左半数组
        quickSort(arr, low, r - 1);
        //递归调用右半数组
        quickSort(arr, r + 1, high);
    }

快排实现TopK

优化为平均O(n)
在这里插入图片描述

 public static void topK(int[] arr, int low, int high, int k) {
        int l, r, temp, t;
        if (low > high) {
            return;
        }
        l = low;
        r = high;
        //temp就是基准位
        temp = arr[low];

        while (l < r) {
            //从右边遍历找到第一个小于temp数的位置
            while (temp <= arr[r] && l < r) {
                r--;
            }
            //从左边遍历找到第一个大于temp数的位置
            while (temp >= arr[l] && l < r) {
                l++;
            }
            //如果满足条件则交换
            if (l < r) {
                t = arr[r];
                arr[r] = arr[l];
                arr[l] = t;
            }

        }
        //最后将基准为与i和j相等位置的数字交换
        arr[low] = arr[l];
        arr[l] = temp;
        if (l == k) return;
            //递归调用左半数组
        else if (l < k) topK(arr, l + 1, high, k);
            //递归调用右半数组
        else topK(arr, low, l - 1, k);
    }

归并排序

package sort;

/**
 * 最佳情况：T(n) = O(n)
 * 最差情况：T(n) = O(nlogn)
 * 平均情况：T(n) = O(nlogn)
 */
public class MergeSort {
    public static void mergeSort(int[] arr, int l, int r) {
        //结束递归条件
        if (l >= r) return;

        int mid = (l + r) / 2;
        //归并左右两半部分
        mergeSort(arr, l, mid);
        mergeSort(arr, mid + 1, r);
        //临时数组，存放arr[l-r]部分
        int[] tmp = new int[r - l + 1];
        int i = l, j = mid + 1, k = 0;
        //归并
        while (i <= mid && j <= r) {
            if (arr[i] < arr[j])
                tmp[k++] = arr[i++];
            else
                tmp[k++] = arr[j++];
        }

        while (i <= mid) tmp[k++] = arr[i++];
        while (j <= r) tmp[k++] = arr[j++];
        //进行赋值
        for (i = l, k = 0; i <= r; i++, k++) {
            arr[i] = tmp[k];
        }
    }
}

死锁

两个线程互相请求对方的锁

ppackage threadAndLock;

public class  DeadLock {
    static Object lock1=new Object();
    static Object lock2=new Object();
    public static void main(String[] args) {
        Thread thread1=new Thread(){
            @Override
            public void run() {
                try{
                    while (true){
                        synchronized (lock1){
                            System.out.println(Thread.currentThread().getName()+"锁住了lock1");
                            Thread.sleep(1000);
                            synchronized (lock2){
                                System.out.println(Thread.currentThread().getName()+"锁住了lock2");
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Thread thread2=new Thread(){
            @Override
            public void run() {
                try{
                    while (true){
                        synchronized (lock2){
                            System.out.println(Thread.currentThread().getName()+"锁住了lock2");
                            Thread.sleep(1000);
                            synchronized (lock1){
                                System.out.println(Thread.currentThread().getName()+"锁住了lock1");
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        thread1.start();
        thread2.start();
    }


}

双线程轮流打印

通过lock的signal精准唤醒，实现轮流打印


package threadAndLock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

//用lock锁实现
class ThreadDemo2 {
    private int number = 1;//标志位，1代表A，2代表B,3代表C
    private Lock lock = new ReentrantLock();
    //设置三把锁
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    public void printA() {
        lock.lock();//加锁
        try {
            while (number != 1) {
                condition1.await();//对标wait()
            }
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);

            }
            number = 2;
            condition2.signal();//可以精准唤醒某个线程
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//解锁，否则会陷入死锁
        }
    }

    public void printB() {
        lock.lock();//加锁
        try {
            while (number != 2) {
                condition2.await();//对标wait()
            }
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);

            }
            number = 3;
            condition3.signal();//可以精准唤醒某个线程()
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//解锁，否则会陷入死锁
        }
    }

    public void printC() {
        lock.lock();//加锁
        try {
            while (number != 3) {
                condition3.await();//对标wait()
            }
            for (int i = 0; i < 15; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            number = 1;
            condition1.signal();//可以精准唤醒某个线程()
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//解锁，否则会陷入死锁
        }
    }
}

/**
 * 三个线程按照顺序调用 A->B->C
 * A打印5次，B打印10次，C打印15次
 * 循环10次
 * 注意：
 * 1.一般多线程方法流程为：判断/干活/通知
 * 2.多线程交互中，必须要防止多线程的虚假唤醒，也即(多线程的程序中不可以用if，必须用while)
 * 3.注意标志位的修改和定位
 */
public class LockTest {
    public static void main(String[] args) {
        ThreadDemo2 threadDemo2 = new ThreadDemo2();
        new Thread("A") {
            @Override
            public void run() {
                for(int i=0;i<9;i++) {
                    threadDemo2.printA();
                }
            }
        }.start();
        new Thread("B") {
            @Override
            public void run() {
                for(int i=0;i<9;i++) {
                    threadDemo2.printB();
                }
            }
        }.start();
        new Thread("C") {
            @Override
            public void run() {
                for(int i=0;i<9;i++) {
                    threadDemo2.printC();
                }
            }
        }.start();
    }
}

自定义线程池

package threadAndLock;

import java.util.concurrent.*;

public class ThreadPool {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newCachedThreadPool();//可扩展线程池
        //自定义线程池
        ExecutorService threadPool1 = new ThreadPoolExecutor(
                2,
                5,
                2,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 10; i++) {
            threadPool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "办理业务");
            });
        }
    }
}

数组实现优先队列

public class PriorityQueue {
    //data[]数组尾为队列头
    //队列头为最大数
    private int[] data;
    private int size;

    PriorityQueue(int size) {
        data = new int[size];
        this.size = 0;
    }

    public void push(int insertNum) throws Exception {
        if (size == data.length)
            throw new Exception("queue is full");
        if (size == 0)
            data[0] = insertNum;
        else {
            int i = size - 1;
            for (; i >= 0; i--) {
                if (insertNum < data[i]) {
                    data[i + 1] = data[i];
                } else
                    break;
            }
            data[i + 1] = insertNum;
        }
        size++;
    }

    public int pop() throws Exception {
        if (size == 0)
            throw new Exception("queue is null");
        return data[--size];
    }

    public int peek() throws Exception {
        if (size == 0)
            throw new Exception("queue is null");
        return data[size - 1];
    }
}

LinkedHashMap实现LRU

import java.util.LinkedHashMap;
import java.util.Map;

public class LRU {
    int size;
    Map<Integer, Integer> map;

    LRU(int size) {
        map = new LinkedHashMap<>();
        this.size = size;
    }
    public int get(int num){
        if(!map.containsKey(num))
            return -1;
        //先删除旧的，再放入新的
        int value=map.get(num);
        map.remove(num);
        map.put(num,value);
        return value;
    }
    public void put(int key,int value){
        //新添加元素注意超出size
        if(!map.containsKey(key)){
            map.put(key,value);
            if(map.size()>size){
                map.remove(map.entrySet().iterator().next().getKey());
            }
        }else{
            map.remove(key);
            map.put(key,value);
        }

    }
}

Flashdog.

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
手撕代码总结

@[TOC]链表环** * 关于链表环的两个结论： * 1.设置快慢指针，假如有环，他们最后一定相遇。(快指针一次两步，慢指针一次一步) * 2.两个指针分别从链表头和相遇点继续出发，每次走一步，最后一定相遇在环入口。 */public class EntryNodeOfLoop { public ListNode entryNodeOfLoop(ListNode pNode) { ListNode low = pNode; ListNode fast =
复制链接

扫一扫