csharp复制代码cat >>oldboy.txt<<EOF
I am oldboy!
I teach linux
EOF

csharp复制代码测验一：找出以m开头的文件内容信息
grep '^m' oldboy.txt

grep命令特点：按行进行操作处理（过滤）
如何给grep命令匹配出来的信息标记颜色
给grep命令设置一个别名
alias grep='grep --color=auto'    临时设置
echo "alias grep='grep --color=auto'">>/etc/profile  永久设置
[root@fu ~]# source /etc/profile         加载

csharp复制代码测验练习二:找出以m结尾的内容信息
[root@fu ~]# grep 'm$' oldboy.txt
my blog is http://oldboy.blog.51cto.com

csharp复制代码[root@fu ~]# grep -v '^m$' oldboy.txt   -v == ！

I am oldboy !
I teach linux

csharp复制代码grep '.' oldboy.txt

csharp复制代码grep '0*' oldboy.txt
什么叫匹配了0次？？

会匹配出文件找不到内容，预支匹配
默认会将所有内容都显示出来

csharp复制代码[root@fu ~]# grep '^m.*' oldboy.txt

mygod ,i am not oldboy,but OLDBOY!

csharp复制代码[root@fu ~]# grep '^m.*m' oldboy.txt

mygod ,i am not oldboy,but!

csharp复制代码01 02 03 04 05

01
02
03
04
05
 tr "要进行替换的信息" "替换成什么信息" alex.txt

[root@fu ~]# tr " " "\n" <alex.txt   空格替换成换行符号
01
02
03
04
05

csharp复制代码[root@fu ~]# grep "[^a-z]" oldboy.txt
I am oldboy !
I teach linux

[root@fu ~]# grep "^[^a-z]" oldboy.txt  不要以小写字母开头的句子
I am oldboy

csharp复制代码[root@fu ~]# egrep '0*' --color  oldboy.txt

I am oldboy !
[root@fu ~]# egrep '3*' --color  oldboy.txt

csharp复制代码[root@fu ~]# grep "[0-9]" oldboy.txt -o
5
1
4
9
0
0
0
4
4
8
4
9
0
0
0
0
0
4
4
8
[root@fu ~]# grep "[0-9]" oldboy.txt 
my blog is sss
[root@fu ~]# grep "[0-9]+" oldboy.txt 
[root@fu ~]# egrep "[0-9]+" oldboy.txt 

not 4900000448

scss复制代码  表示匹配一个整体消息  egrep 'oldb(o|e)y' 表示过滤整体信息
  表示用于后项引用前项  sed -r 's#(.*)#</1>#g'  利用sed命令实现后项引用前项
                       sed -r  's#([0-9]+)#<\1>#g'利用sed命令实现后项引用前项
					   sed -r  's#(12)(34)(56)#<\1><\2><\3>#g'利用sed命令实现后项引用前项
  
  
  
  [root@fu ~]# egrep 'oldb[oe]y' oldboy.txt
  I am oldboy teacher!
  [root@fu ~]# egrep 'oldb(oe)y' oldboy.txt
  [root@fu ~]# egrep 'oldb(o|e)y' oldboy.txt
  I am oldboy teacher!

java复制代码@Data
public class SignIn implements Serializable {
    private long id;//注意id为long类型
    private String owner;
    private String modifier;
    private String last_modified;
    private String created_at;
    private String modified_method;
    private String app_key;
    private String app_extend_key;
    private String canjiayixiangxin;
    private String canjiashijian;
    private String canjiaren;
    private String yanlianliushuihao;
}

java复制代码<!--插入数据至台账从表-->
    <insert id="insertParameter"  useGeneratedKeys="true" keyProperty="id" keyColumn="id" >
        insert into
        	${tableId}(
         owner,modifier,last_modified,created_at,modified_method,app_key,app_extend_key, canjiayixiangxin,canjiashijian,canjiaren,yanlianliushuihao)
        values
        <foreach collection="list" index="index" item="ids" separator=",">
            (
            #{ids.owner},#{ids.modifier},#{ids.last_modified},#{ids.created_at},#		{ids.modified_method},#{ids.app_key},#{ids.app_extend_key}, #{ids.canjiayixiangxin},#{ids.canjiashijian},#{ids.canjiaren},#{ids.yanlianliushuihao}
            )
        </foreach>
    </insert>

java复制代码//如果数据为空,结束,不需要再执行下去
if (CollectionUtils.isEmpty(resultList)){
     return;
  }
 //格式化时间                       
 SimpleDateFormat sdfDay = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
 List<SignIn> signInList = new ArrayList<>();
 for (Map map : resultList){
 	map.put("created_at",sdfDay.format(map.get("created_at")));
 	map.put("canjiashijian",sdfDay.format(map.get("canjiashijian")));
 	map.put("last_modified",sdfDay.format(map.get("last_modified")));
 	map.remove("id");
 	//转为实体类,这里每次需要重新new一个对象,不然id会被覆盖成最后一个的id
 	SignIn signIn = new SignIn();
 	signInList.add(BeanUtils.mapToBean(map,signIn));
  }

java复制代码public class BeanUtils {

    private BeanUtils() {throw new IllegalStateException();
    }
    /**
     * map转bean
     *
     * @param map
     * @param bean
     * @param <T>
     * @return
     */
    public static <T> T mapToBean(Map<String, Object> map, T bean) {
        BeanMap beanMap = BeanMap.create(bean);
        beanMap.putAll(map);
        return bean;
    }
}

json复制代码PUT juejin_hr_data_v1

{

  "settings": {

    "index": {

      "routing": {

        "allocation": {

          "enable": "all"

        }

      },

      "refresh_interval": "60s",

      "number_of_shards": "3"

    }

  },

  "mappings": {

    "dynamic": false,

    "properties": {

      "week": {

        "type": "keyword"

      },

      "team": {

        "type": "keyword"

      },

      "school":{

        "type":"integer"

      },

      "nowcoder":{

        "type":"integer"

      },

      "boss":{

        "type":"integer"

      },

      "maimai":{

        "type":"integer"

      }

    }

  }

}

json复制代码POST juejin_hr_data_v1/_bulk // bulk api，批量写入

{"index":{"_id":"client_1"}}

{"week":1,"team":"客户端","school":0,"nowcoder":0,"boss":0,"maimai":0}

bash复制代码POST juejin_hr_data_v1/_delete_by_query

{

  "query": {

    "match_all": {}

  }

}

bash复制代码覆盖写

PUT juejin_hr_data_v1/_doc/1 //没有指定的index会创建

{

  "week":1,"team":"客户端","school":0,"nowcoder":0,"boss":0,"maimai":0

}

PUT juejin_hr_data_v1/_create/1 //没有指定的index会报错

{

  "week":1,"team":"客户端","school":0,"nowcoder":0,"boss":0,"maimai":0

}



更新部分字段

POST juejin_hr_data_v1/1/_update

{

  "doc":{

    "week":2

  }

}

bash复制代码GET juejin_hr_data_v1/_search

{

  "query": {

    "match_all": {}

  }

}

yaml复制代码node.master: true 

node.data: true

yaml复制代码node.master: true 

node.data: false

yaml复制代码node.master: false 

node.data: true

yaml复制代码node.master: false 

node.data: false

markdown复制代码{

  "mappings": {

    "dynamic_templates": [

      {

        "strings_as_keywords": {

          "match_mapping_type": "string",

          "mapping": {

            "type": "text"

          }

        }

      }

    ]

}

css复制代码 "a":      {2}

 "banana": {2}

 "is":     {0, 1, 2}

 "it":     {0, 1, 2}

 "what":   {0, 1}

js复制代码(async () => {
  const ab2str = (buffer) => String.fromCharCode.apply(null, new Uint8Array(buffer));
  const saveFile = async (files) => {
    Object.keys(files).forEach(file => {
      const blob = new Blob([files[file]], { type: 'text/plain' });
      with (document.createElement('a')) { download = file; href = URL.createObjectURL(blob); click(); }
      URL.revokeObjectURL(blob);
    });
  }
  const exportKey = (content) => new Promise(async (resolve) => { await crypto.subtle.exportKey(content.type === "private" ? "pkcs8" : "spki", content).then((data) => resolve(`-----BEGIN ${content.type.toUpperCase()} KEY-----\n${btoa(ab2str(data))}\n-----END ${content.type.toUpperCase()} KEY-----`)); });
  const { privateKey, publicKey } = await crypto.subtle.generateKey({ name: "RSA-OAEP", modulusLength: 4096, publicExponent: new Uint8Array([1, 0, 1]), hash: "SHA-256" }, true, ["encrypt", "decrypt"])
  saveFile({ "rsa.key": await exportKey(privateKey), "rsa.pub": await exportKey(publicKey) });
})();

js复制代码const fs = require('fs');
if (typeof crypto == 'undefined') {
  crypto = require('crypto').webcrypto;
}

function pem_to_der(pem, type) {
  const pemJoined = pem.toString().split('\n').join('');
  const pemHeader = `-----BEGIN ${type} KEY-----`;
  const pemFooter = `-----END ${type} KEY-----`;
  const pemContents = pemJoined.substring(pemHeader.length, pemJoined.length - pemFooter.length);
  return Buffer.from(pemContents, 'base64');
}

const rsaKeys = {
  public: fs.readFileSync(`/etc/nginx/script/rsa.pub`),
  private: fs.readFileSync(`/etc/nginx/script/rsa.key`)
}

async function simple(req) {

  const spki = await crypto.subtle.importKey("spki", pem_to_der(rsaKeys.public, "PUBLIC"), { name: "RSA-OAEP", hash: "SHA-256" }, false, ["encrypt"]);
  const pkcs8 = await crypto.subtle.importKey("pkcs8", pem_to_der(rsaKeys.private, "PRIVATE"), { name: "RSA-OAEP", hash: "SHA-256" }, false, ["decrypt"]);

  let originText = "假设这是需要加密的内容，by soulteary";

  let enc = await crypto.subtle.encrypt({ name: "RSA-OAEP" }, spki, originText);
  let decode = await crypto.subtle.decrypt({ name: "RSA-OAEP" }, pkcs8, enc);

  req.headersOut["Content-Type"] = "text/html;charset=UTF-8";
  req.return(200, [
    '<h2>原始内容</h2>',
    `<code>${originText}</code>`,
    '<h2>加密后的内容</h2>',
    `<code>${Buffer.from(enc)}</code>`,
    '<h2>解密后的内容</h2>',
    `<code>${Buffer.from(decode)}</code>`,
  ].join(''));
}

export default { simple };

bash复制代码load_module modules/ngx_http_js_module.so;

user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log notice;
pid /var/run/nginx.pid;

events { worker_connections 1024; }

http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;

    js_import app from script/app.js;

    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
    '$status $body_bytes_sent "$http_referer" '
    '"$http_user_agent" "$http_x_forwarded_for"';

    access_log /var/log/nginx/access.log main;

    keepalive_timeout 65;
    gzip on;

    server {
        listen 80;
        server_name localhost;

        charset utf-8;
        gzip on;

        location / {
            js_content app.simple;
        }
    }
}

yaml复制代码version: '3'

services:

  nginx-rsa-demo:
    image: nginx:1.21.4-alpine
    ports:
      - 8080:80
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./scripts:/etc/nginx/script

bash复制代码server {
    listen 80;
    server_name localhost;

    charset utf-8;
    gzip on;

    location / {
        js_content app.entrypoint;
    }

    location /api/encrypt {
        js_content app.encrypt;
    }

    location /api/decrypt {
        js_content app.decrypt;
    }
}

bash复制代码export default { encrypt, decrypt, entrypoint };

bash复制代码function debug(req) {
  req.headersOut["Content-Type"] = "text/html;charset=UTF-8";
  req.return(200, JSON.stringify(req, null, 4));
}

function encrypt(req) {
  debug(req)
}

function decrypt(req) {
  debug(req)
}

function entrypoint(r) {
  r.headersOut["Content-Type"] = "text/html;charset=UTF-8";
  switch (r.method) {
    case 'GET':
      return r.return(200, [
        '<form action="/" method="post">',
        '<input name="data" value=""/>',
        '<input type="radio" name="action" id="encrypt" value="encrypt" checked="checked"/><label for="encrypt">Encrypt</label>',
        '<input type="radio" name="action" id="decrypt" value="decrypt"/><label for="decrypt">Decrypt</label>',
        '<button type="submit">Submit</button>',
        '</form>'
      ].join('<br>'));
    case 'POST':
      var body = r.requestBody;
      if (r.headersIn['Content-Type'] != 'application/x-www-form-urlencoded' || !body.length) {
        r.return(401, "Unsupported method\n");
      }

      var params = body.trim().split('&').reduce(function (prev, item) {
        var tmp = item.split('=');
        var key = decodeURIComponent(tmp[0]).trim();
        var val = decodeURIComponent(tmp[1]).trim();
        if (key === 'data' || key === 'action') {
          if (val) {
            prev[key] = val;
          }
        }
        return prev;
      }, {});

      if (!params.action || (params.action != 'encrypt' && params.action != 'decrypt')) {
        return r.return(400, 'Invalid Params: `action`.');
      }

      if (!params.data) {
        return r.return(400, 'Invalid Params: `data`.');
      }

      function response_cb(res) {
        r.return(res.status, res.responseBody);
      }

      return r.subrequest(`/api/${params.action}`, { method: 'POST' }, response_cb)
    default:
      return r.return(400, "Unsupported method\n");
  }
}

export default { encrypt, decrypt, entrypoint };

js复制代码async function encrypt(req) {
  const spki = await crypto.subtle.importKey("spki", pem_to_der(rsaKeys.public, "PUBLIC"), { name: "RSA-OAEP", hash: "SHA-256" }, false, ["encrypt"]);
  const result = await crypto.subtle.encrypt({ name: "RSA-OAEP" }, spki, req.requestText);
  req.return(200, Buffer.from(result));
}

js复制代码function entrypoint(r) {
  r.headersOut["Content-Type"] = "text/html;charset=UTF-8";

  switch (r.method) {
    case 'GET':
      return r.return(200, [
        '<form action="/" method="post">',
        '<input name="data" value=""/>',
        '<input type="radio" name="action" id="encrypt" value="encrypt" checked="checked"/><label for="encrypt">Encrypt</label>',
        '<input type="radio" name="action" id="decrypt" value="decrypt"/><label for="decrypt">Decrypt</label>',
        '<input type="radio" name="base64" id="base64-on" value="on" checked="checked"/><label for="base64-on">Base64 On</label>',
        '<input type="radio" name="base64" id="base64-off" value="off" /><label for="base64-off">Base64 Off</label>',
        '<button type="submit">Submit</button>',
        '</form>'
      ].join('<br>'));
    case 'POST':
      var body = r.requestBody;
      if (r.headersIn['Content-Type'] != 'application/x-www-form-urlencoded' || !body.length) {
        r.return(401, "Unsupported method\n");
      }

      var params = body.trim().split('&').reduce(function (prev, item) {
        var tmp = item.split('=');
        var key = decodeURIComponent(tmp[0]).trim();
        var val = decodeURIComponent(tmp[1]).trim();
        if (key === 'data' || key === 'action' || key === 'base64') {
          if (val) {
            prev[key] = val;
          }
        }
        return prev;
      }, {});

      if (!params.action || (params.action != 'encrypt' && params.action != 'decrypt')) {
        return r.return(400, 'Invalid Params: `action`.');
      }

      if (!params.base64 || (params.base64 != 'on' && params.base64 != 'off')) {
        return r.return(400, 'Invalid Params: `base64`.');
      }

      if (!params.data) {
        return r.return(400, 'Invalid Params: `data`.');
      }

      function response_cb(res) {
        r.return(res.status, res.responseBody);
      }

      return r.subrequest(`/api/${params.action}${params.base64 === 'on' ? '?base64=1' : ''}`, { method: 'POST', body: params.data }, response_cb)
    default:
      return r.return(400, "Unsupported method\n");
  }
}

js复制代码async function encrypt(req) {
  const needBase64 = req.uri.indexOf('base64=1') > -1;
  const spki = await crypto.subtle.importKey("spki", pem_to_der(rsaKeys.public, "PUBLIC"), { name: "RSA-OAEP", hash: "SHA-256" }, false, ["encrypt"]);
  const result = await crypto.subtle.encrypt({ name: "RSA-OAEP" }, spki, req.requestText);
  if (needBase64) {
    req.return(200, Buffer.from(result).toString("base64"));
  } else {
    req.headersOut["Content-Type"] = "application/octet-stream";
    req.return(200, Buffer.from(result));
  }
}

js复制代码async function decrypt(req) {
  const needBase64 = req.uri.indexOf('base64=1') > -1;
  const pkcs8 = await crypto.subtle.importKey("pkcs8", pem_to_der(rsaKeys.private, "PRIVATE"), { name: "RSA-OAEP", hash: "SHA-256" }, false, ["decrypt"]);
  const encrypted = needBase64 ? Buffer.from(req.requestText, 'base64') : Buffer.from(req.requestText);
  const result = await crypto.subtle.decrypt({ name: "RSA-OAEP" }, pkcs8, encrypted);
  req.return(200, Buffer.from(result));
}

bash复制代码server {
    listen 8081;
    server_name localhost;

    charset utf-8;
    gzip on;

    location / {
        js_content mock.mockEncData;
    }
}

server {
    listen 8082;
    server_name localhost;

    charset utf-8;
    gzip on;

    location / {
        js_content mock.mockRawData;
    }
}

bash复制代码js_import mock from script/mock.js;

yaml复制代码version: '3'

services:

  nginx-api-demo:
    image: nginx:1.21.4-alpine
    restart: always
    ports:
      - 8080:80
      - 8081:8081
      - 8082:8082
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./scripts:/etc/nginx/script

js复制代码function randomPick() {
    const powerWords = ['苏洋博客', '专注硬核', '分享有趣'];
    return powerWords[Math.floor(Math.random() * powerWords.length)];
}

function mockRawData(r) {
    r.headersOut["Content-Type"] = "text/html;charset=UTF-8";
    r.return(200, randomPick());
}

const fs = require('fs');
if (typeof crypto == 'undefined') {
    crypto = require('crypto').webcrypto;
}

function pem_to_der(pem, type) {
    const pemJoined = pem.toString().split('\n').join('');
    const pemHeader = `-----BEGIN ${type} KEY-----`;
    const pemFooter = `-----END ${type} KEY-----`;
    const pemContents = pemJoined.substring(pemHeader.length, pemJoined.length - pemFooter.length);
    return Buffer.from(pemContents, 'base64');
}

const publicKey = fs.readFileSync(`/etc/nginx/script/rsa.pub`);

async function mockEncData(r) {
    const spki = await crypto.subtle.importKey("spki", pem_to_der(publicKey, "PUBLIC"), { name: "RSA-OAEP", hash: "SHA-256" }, false, ["encrypt"]);
    const result = await crypto.subtle.encrypt({ name: "RSA-OAEP" }, spki, randomPick());

    r.headersOut["Content-Type"] = "text/html;charset=UTF-8";
    r.headersOut["Encode-State"] = "ON";
    r.return(200, Buffer.from(result).toString("base64"));
}

export default { mockEncData, mockRawData };

bash复制代码location /remote/need-encrypt {
    proxy_pass http://localhost:8082/;
}

location /remote/need-decrypt {
    proxy_pass http://localhost:8081/;
}

bash复制代码location /auto{
    js_content app.auto;
}

js复制代码async function auto(req) {
  req.headersOut["Content-Type"] = "text/html;charset=UTF-8";

  let remoteAPI = "";
  switch (req.args.action) {
    case "encrypt":
      remoteAPI = "/remote/need-encrypt";
      break;
    case "decrypt":
    default:
      remoteAPI = "/remote/need-decrypt";
      break;
  }

  async function autoCalc(res) {
    const isEncoded = res.headersOut['Encode-State'] == "ON";
    const remoteRaw = res.responseText;
    if (isEncoded) {
      const pkcs8 = await crypto.subtle.importKey("pkcs8", pem_to_der(rsaKeys.private, "PRIVATE"), { name: "RSA-OAEP", hash: "SHA-256" }, false, ["decrypt"]);
      const encrypted = Buffer.from(remoteRaw, 'base64');
      const result = await crypto.subtle.decrypt({ name: "RSA-OAEP" }, pkcs8, encrypted);
      req.return(200, Buffer.from(result));
    } else {
      const spki = await crypto.subtle.importKey("spki", pem_to_der(rsaKeys.public, "PUBLIC"), { name: "RSA-OAEP", hash: "SHA-256" }, false, ["encrypt"]);
      const dataEncrypted = await crypto.subtle.encrypt({ name: "RSA-OAEP" }, spki, remoteRaw);
      req.return(200, Buffer.from(dataEncrypted).toString("base64"));
    }
  }

  req.subrequest(remoteAPI, { method: "GET" }, autoCalc)
}


export default { encrypt, decrypt, entrypoint, auto };

js复制代码async function auto(req) {
  req.headersOut["Content-Type"] = "text/html;charset=UTF-8";

  function randomSource() {
    const sources = ["/remote/need-encrypt", "/remote/need-decrypt"];
    return sources[Math.floor(Math.random() * sources.length)];
  }

  async function autoCalc(res) {
    const isEncoded = res.headersOut['Encode-State'] == "ON";
    const remoteRaw = res.responseText;
    if (isEncoded) {
      const pkcs8 = await crypto.subtle.importKey("pkcs8", pem_to_der(rsaKeys.private, "PRIVATE"), { name: "RSA-OAEP", hash: "SHA-256" }, false, ["decrypt"]);
      const encrypted = Buffer.from(remoteRaw, 'base64');
      const result = await crypto.subtle.decrypt({ name: "RSA-OAEP" }, pkcs8, encrypted);
      req.return(200, [
        "<h2>原始内容</h2>",
        `<code>${remoteRaw}</code>`,
        "<h2>处理后的内容</h2>",
        `<code>${Buffer.from(result)}</code>`
      ].join(""));
    } else {
      const spki = await crypto.subtle.importKey("spki", pem_to_der(rsaKeys.public, "PUBLIC"), { name: "RSA-OAEP", hash: "SHA-256" }, false, ["encrypt"]);
      const dataEncrypted = await crypto.subtle.encrypt({ name: "RSA-OAEP" }, spki, remoteRaw);
      req.return(200, [
        "<h2>原始内容</h2>",
        `<code>${remoteRaw}</code>`,
        "<h2>处理后的内容</h2>",
        `<code>${Buffer.from(dataEncrypted).toString("base64")}</code>`
      ].join(""));
    }
  }

  req.subrequest(randomSource(), { method: "GET" }, autoCalc)
}

js复制代码location /remote/need-encrypt {
    internal;
    proxy_pass http://localhost:8082/;
}

location /remote/need-decrypt {
    internal;
    proxy_pass http://localhost:8081/;
}

location /api/encrypt {
    internal;
    js_content app.encrypt;
}

location /api/decrypt {
    internal;
    js_content app.decrypt;
}

css复制代码输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

lua复制代码输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]

lua复制代码输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]

ini复制代码输入：head = []
输出：[]
解释：给定的链表为空（空指针），因此返回 null。

c复制代码/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
public:
    Node* copyRandomList(Node* head) {
        for(auto p = head; p; p = p->next->next)  //复制每个节点，并将原链表和复制链表连在一起。
        {
            auto q = new Node(p->val);
            q->next = p->next;
            p->next = q;
        }

        for(auto p = head; p; p = p->next->next)   //复制random指针
        {
            if(p->random)
              p->next->random = p->random->next;
        }

        //拆分两个链表，并复原原链表
        auto dummy = new Node(-1), cur = dummy; 
        for(auto p = head; p; p = p->next)
        {
            auto q = p->next;
            cur = cur->next = q;
            p->next = q->next;
        }

        return dummy->next;
    }
};

java复制代码/*
// Definition for a Node.
class Node {
    int val;
    Node next;
    Node random;

    public Node(int val) {
        this.val = val;
        this.next = null;
        this.random = null;
    }
}
*/

class Solution {
    public Node copyRandomList(Node head) {
        for(Node p = head; p != null; p = p.next.next)  //复制每个节点，并将原链表和复制链表连在一起。
        {
            Node q = new Node(p.val);
            q.next = p.next;
            p.next = q;
        }

        for(Node p = head; p != null; p = p.next.next)   //复制random指针
        {
            if(p.random != null)
              p.next.random = p.random.next;
        }

        //拆分两个链表，并复原原链表
        Node dummy = new Node(-1), cur = dummy;
        for(Node p = head; p != null; p = p.next)
        {
            Node q = p.next;
            cur = cur.next = q;
            p.next = q.next;
        }

        return dummy.next;
    }
}

c复制代码class Solution {
public:
    unordered_map<Node*, Node*> hash;

    Node* copyRandomList(Node* head) 
    {
        if (head == NULL)  return NULL;
        return dfs(head);   
    }

    Node* dfs(Node* node)
    {
        if(node == NULL) return NULL;
        //node节点已经被访问过了,直接从哈希表hash中取出对应的克隆节点返回。
        if(hash.count(node))  return hash[node]; 
        Node* clone = new Node(node->val);    //复制节点
        hash[node] = clone;                   //建立源节点到复制节点的映射   
        clone->next = dfs(node->next);        //复制边  
        clone->random = dfs(node->random);
        return clone;
    }
};

java复制代码/*
// Definition for a Node.
class Node {
    int val;
    Node next;
    Node random;

    public Node(int val) {
        this.val = val;
        this.next = null;
        this.random = null;
    }
}
*/

class Solution {
    Map<Node,Node> hash = new HashMap<>();
    public Node copyRandomList(Node head) {
        if(head == null) return null;
        return dfs(head);
    }
    Node dfs(Node node)
    {
        if(node == null) return null;
        //node节点已经被访问过了,直接从哈希表hash中取出对应的复制节点返回。
        if(hash.containsKey(node)) return hash.get(node); 
        Node clone = new Node(node.val);  //复制节点
        hash.put(node,clone);   		  //建立源节点到复制节点的映射
        clone.next = dfs(node.next);      //复制边  
        clone.random = dfs(node.random);
        return clone;
    }
}

java复制代码import java.util.LinkedList;

/**
 * @author xuls
 * @date 2021/11/14 16:23
 * LRU 缓存淘汰算法
 */
public class LRU <T>{
	private LinkedList<T> list;
	private int capacity;   //缓存容量

	public LRU() {
		this(10);
	}

	public LRU(int capacity) {
		this.capacity = capacity;
		list = new LinkedList<>();
	}

	public void add(T data){
		if (list.size() < capacity){
			//缓存未满，直接添加到链表头部，表明该数据最近在使用
			list.addFirst(data);
		}else {
			//链表之中是否包含 data
			if (list.contains(data)){
				//链表包含 data ,先将包含的数据移除
				list.remove(data);
			}else {
				//链表不包含 data ，移除最后一个，因为最后一个是最近最少使用的
				list.removeLast();
			}
			//将新数据添加到前面
			list.addFirst(data);
		}
	}

	@Override
	public String toString() {
		return "LRU{" +
				"list=" + list +
				'}';
	}

	public static void main(String[] args) {
		LRU<String> stringLRU = new LRU<>();
		for (int i = 0; i < 10; i++) {
			stringLRU.add("s"+i);
		}
		System.out.println(stringLRU);
		stringLRU.add("s1");
		System.out.println(stringLRU);
		stringLRU.add("s10");
		System.out.println(stringLRU);
	}
}

java复制代码@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket docket(){
        return new Docket(DocumentationType.SWAGGER_2).apiInfo();
    }
    //配置Swagger信息==>ApiInfo
    public ApiInfo apiInfo(){
        //作者信息
        Contact contact=new Contact("杨明宇","http://blog.ymy12138.cn","1064576969@qq.com");
        return new ApiInfo("Api Documentation",//标题
                "Api Documentation",//详细描述
                "1.0",//版本
                "urn:tos",//开发者信息，可以是个网站
                contact,//作者信息
                "Apache 2.0",//依赖
                "http://www.apache.org/licenses/LICENSE-2.0",
                new ArrayList());

    }
}

java复制代码
return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .enable(true);
                .apis(RequestHandlerSelectors.xxx())
                .paths(PathSelectors.yyy());
                .build();
//apis，扫描哪些
//xxx
//1. basePackage：指定要扫描的包，一般就使用这个就可以了
//2. any()：扫描全部
//3. none()：不扫描
//4. withClassAnnotation：扫描类上的注解，注解的反射对象
//5. withMethodAnnotation：扫描方法上的注解
//****************************************************
//paths，过滤掉哪些
//yyy
//1. ant()：表示过滤哪个包
//2. any()：表示过滤全部
//3. none()：表示都不过滤
//**************************************
//enable，表示是否打开swagger的功能，默认true，如果修改成false，那么就无法正常使用swagger功能

java复制代码return new Docket(DocumentationType.SWAGGER_2)
            .apiInfo(apiInfo())
            .enable(flag);
            .select()
            .apis(RequestHandlerSelectors.xxx())
            .paths(PathSelectors.yyy());
            .build();

java复制代码package com.ymy.swagger.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.core.env.Profiles;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.service.Documentation;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
import sun.security.acl.AllPermissionsImpl;

import java.util.ArrayList;

/**
 * @Version 1.0
 * @Author:ymy
 * @Date:2019/8/31
 * @Content:
 */

@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket docket(Environment environment){
        Profiles profiles=Profiles.of("dev","test");
        boolean flag=environment.acceptsProfiles(profiles);
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .enable(flag)
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.ymy"))
                .build();
    }
    //配置Swagger信息==>ApiInfo
    public ApiInfo apiInfo(){
        //作者信息
        Contact contact=new Contact("杨明宇","http://blog.ymy12138.cn","1064576969@qq.com");
        return new ApiInfo("Api Documentation",//标题
                "Api Documentation",//详细描述
                "1.0",//版本
                "urn:tos",//开发者信息，可以是个网站
                contact,//作者信息
                "Apache 2.0",//依赖
                "http://www.apache.org/licenses/LICENSE-2.0",
                new ArrayList());
    }
}

java复制代码
@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket docket(){
        return new Docket(DocumentationType.SWAGGER_2).apiInfo();
    }
    //配置Swagger信息==>ApiInfo
    public ApiInfo apiInfo(){
        //作者信息
        Contact contact=new Contact("杨明宇","http://blog.ymy12138.cn","1064576969@qq.com");
        return new ApiInfo("Api Documentation",//标题
                "Api Documentation",//详细描述
                "1.0",//版本
                "urn:tos",//开发者信息，可以是个网站
                contact,//作者信息
                "Apache 2.0",//依赖
                "http://www.apache.org/licenses/LICENSE-2.0",
                new ArrayList());

    }
}

arduino复制代码示例 1：

输入：word1 = "aaaa", word2 = "bccb"
输出：false
解释：字符串 "aaaa" 中有 4 个 'a' ，但是 "bccb" 中有 0 个 'a' 。
两者之差为 4 ，大于上限 3 。
示例 2：

输入：word1 = "abcdeef", word2 = "abaaacc"
输出：true
解释：word1 和 word2 中每个字母出现频率之差至多为 3 ：
- 'a' 在 word1 中出现了 1 次，在 word2 中出现了 4 次，差为 3 。
- 'b' 在 word1 中出现了 1 次，在 word2 中出现了 1 次，差为 0 。
- 'c' 在 word1 中出现了 1 次，在 word2 中出现了 2 次，差为 1 。
- 'd' 在 word1 中出现了 1 次，在 word2 中出现了 0 次，差为 1 。
- 'e' 在 word1 中出现了 2 次，在 word2 中出现了 0 次，差为 2 。
- 'f' 在 word1 中出现了 1 次，在 word2 中出现了 0 次，差为 1 。
示例 3：

输入：word1 = "cccddabba", word2 = "babababab"
输出：true
解释：word1 和 word2 中每个字母出现频率之差至多为 3 ：
- 'a' 在 word1 中出现了 2 次，在 word2 中出现了 4 次，差为 2 。
- 'b' 在 word1 中出现了 2 次，在 word2 中出现了 5 次，差为 3 。
- 'c' 在 word1 中出现了 3 次，在 word2 中出现了 0 次，差为 3 。
- 'd' 在 word1 中出现了 2 次，在 word2 中出现了 0 次，差为 2 。

cpp复制代码class Solution {
public:
    bool checkAlmostEquivalent(string word1, string word2) {

        int a[26]={0};
        for (int i = 0; i < word1.size(); ++i) {
            a[word1[i]-'a']++;
        }
        for (int j = 0; j < word2.size(); ++j) {
            a[word2[j]-'a']--;
        }
        for (int i = 0; i < 26; ++i) {
            if (abs(a[i])>3)
                return false;
        }
        return true;
    }
};